diff --git a/README.md b/README.md index dd195c1..d37d800 100644 --- a/README.md +++ b/README.md @@ -74,6 +74,7 @@ at the time; the last full run on the Simulator is under | [`sensors_plus_watchos`](packages/sensors_plus_watchos) [![pub](https://img.shields.io/pub/v/sensors_plus_watchos.svg)](https://pub.dev/packages/sensors_plus_watchos) | [`sensors_plus`](https://pub.dev/packages/sensors_plus) | CoreMotion (`CMMotionManager`) | | [`local_auth_watchos`](packages/local_auth_watchos) [![pub](https://img.shields.io/pub/v/local_auth_watchos.svg)](https://pub.dev/packages/local_auth_watchos) | [`local_auth`](https://pub.dev/packages/local_auth) | LocalAuthentication (passcode) | | [`geolocator_watchos`](packages/geolocator_watchos) [![pub](https://img.shields.io/pub/v/geolocator_watchos.svg)](https://pub.dev/packages/geolocator_watchos) | [`geolocator`](https://pub.dev/packages/geolocator) | CoreLocation (`CLLocationManager`) | +| [`permission_handler_watchos`](packages/permission_handler_watchos) | [`permission_handler`](https://pub.dev/packages/permission_handler) | UserNotifications, and CoreLocation, CoreMotion, AVFAudio, Contacts, EventKit, CoreBluetooth and Intents loaded at runtime | | [`sqflite_watchos`](packages/sqflite_watchos) | [`sqflite`](https://pub.dev/packages/sqflite) | The system SQLite (`libsqlite3`), its C API called from Dart | | [`video_player_watchos`](packages/video_player_watchos) [![pub](https://img.shields.io/pub/v/video_player_watchos.svg)](https://pub.dev/packages/video_player_watchos) | [`video_player`](https://pub.dev/packages/video_player) | AVFoundation + AVKit platform view | | [`audioplayers_watchos`](packages/audioplayers_watchos) [![pub](https://img.shields.io/pub/v/audioplayers_watchos.svg)](https://pub.dev/packages/audioplayers_watchos) | [`audioplayers`](https://pub.dev/packages/audioplayers) | AVFoundation (`AVPlayer`) | diff --git a/packages/permission_handler_watchos/.gitignore b/packages/permission_handler_watchos/.gitignore new file mode 100644 index 0000000..7b8ac9e --- /dev/null +++ b/packages/permission_handler_watchos/.gitignore @@ -0,0 +1,23 @@ +# Dart / Flutter +.dart_tool/ +build/ +.flutter-plugins +.flutter-plugins-dependencies +.packages +.pub/ + +# Xcode / SwiftPM (per-user, generated when watchos/Package.swift is opened) +**/.swiftpm/ +**/.build/ +**/xcuserdata/ + +# flutter-watchos app wiring (generated in an app's watchos/, never a plugin's) +watchos/Flutter/ + +# IDE +.idea/ +.vscode/ +*.iml + +# macOS +.DS_Store diff --git a/packages/permission_handler_watchos/CHANGELOG.md b/packages/permission_handler_watchos/CHANGELOG.md new file mode 100644 index 0000000..b9425b2 --- /dev/null +++ b/packages/permission_handler_watchos/CHANGELOG.md @@ -0,0 +1,29 @@ +## 0.0.1 + +First version, staged: checked on the watchOS 27.0 Simulator, not yet on a +physical watch. + +* `PermissionHandlerWatchos` answers `permission_handler` on watchOS over + dart:ffi: status, service status and requests for location (when in use + and always), notifications, critical alerts, sensors, the microphone, + contacts, the calendar (full access and write only), reminders, Bluetooth + and Siri (`assistant`, for an app that sets `PermissionHandlerWatchosSiri` + in its Info.plist), with the iOS implementation's statuses and error + codes. `storage` is granted, as on iOS. +* Each framework but UserNotifications is loaded at runtime instead of + linked. Every group's class names and selectors are still in the binary, + unlike the iOS implementation, whose build macros leave a group out; + whether App Store Connect's usage-description check reads them is not yet + known (see the README). +* The location strategy keeps one flag in `NSUserDefaults`, so apps declare + `NSPrivacyAccessedAPICategoryUserDefaults` (`CA92.1`) in their privacy + manifest. +* A request whose usage description is missing fails with + `MISSING_USAGE_DESCRIPTION` instead of the app being terminated. A request + while another waits fails with `ERROR_ALREADY_REQUESTING_PERMISSIONS`, as + on iOS. A location prompt closed without an answer answers denied, as on + iOS; watchOS sends no delegate call then, so the app becoming active + again is the answer. +* The example's `lib/` is permission_handler_apple's own example, + unchanged, with `url_launcher_watchos` for its template's links; a + watchOS integration test checks the answers that need no prompt. diff --git a/packages/permission_handler_watchos/LICENSE b/packages/permission_handler_watchos/LICENSE new file mode 100644 index 0000000..bd6192f --- /dev/null +++ b/packages/permission_handler_watchos/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Baseflow + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/permission_handler_watchos/PORTING_REPORT.md b/packages/permission_handler_watchos/PORTING_REPORT.md new file mode 100644 index 0000000..4b546fc --- /dev/null +++ b/packages/permission_handler_watchos/PORTING_REPORT.md @@ -0,0 +1,157 @@ +# permission_handler_watchos — porting report + +## Verification status + +| Aspect | Result | +|---|---| +| Implementation | ✅ Working (FFI; one strategy per permission group, as in the iOS implementation) | +| watchOS capability | ◐ The permissions watchOS has: location (when in use and always), notifications, critical alerts, sensors, microphone, contacts, calendar (full access and write only), reminders, Bluetooth, Siri; storage is granted as on iOS. The others answer as iOS answers for a permission it does not know | +| Host unit tests (`flutter test`) | ✅ 8 pass | +| Upstream integration test | ○ none upstream (Baseflow's example is a manual demo) | +| watchOS integration test (`example/integration_test/permission_handler_test.dart`) | ✅ 5 pass on the watchOS 27.0 Simulator | +| System prompts | ✅ asked for on the Simulator, each answered as on iOS: notification granted; location when in use granted; location always kept at "while using" → permanentlyDenied; sensors granted; microphone granted; contacts refused → permanentlyDenied; reminders granted; calendar write only granted. Bluetooth reads granted on the Simulator, which has no Bluetooth. After the review fixes, location when in use again: the prompt closed with the crown → answered, and a second request prompted again; allowed → granted; "always" asked for right after → its prompt stayed up until answered, kept at "while using" → permanentlyDenied. In upstream's example: calendar (full access) allowed → granted | +| Critical alerts and Siri prompts | not yet asked for: each needs an entitlement the example does not have | +| App Store Connect upload | not yet done: whether ITMS-90683 reads the class names of groups an app does not use is unchecked (see "Design") | +| Example deviations | `example/pubspec.yaml` adds `url_launcher_watchos`, for the links of `baseflow_plugin_template`, which go through `url_launcher`. `example/lib/main.dart` is otherwise upstream's, formatted as this repo's CI checks | +| Physical watch | not yet checked | + +Marking: ✅ full / passes · ◐ partial — reason given · ○ not applicable (no upstream test) · ✗ unsupported on watchOS. + +> This scaffold has been **finished by hand** into a working FFI package; see +> the status above. The generated notes below are kept for provenance. + +## Design + +The iOS implementation compiles each permission group in or out with a +preprocessor macro (`PERMISSION_CONTACTS=1` and so on, all off by default), so +that an app does not reference an API it never asks for: App Store Connect +warns about a missing usage description (ITMS-90683) for the privacy APIs a +binary references. A watch app has no Podfile to set those macros, and the +flutter-watchos CLI compiles plugin sources with fixed flags, so every group +is compiled into every app. Each framework is loaded with `dlopen` and its +classes looked up by name the first time a permission of its group is asked +about, and only messaged; of the frameworks, only UserNotifications, which +needs no usage description, is linked. `nm -u` on the compiled objects shows +no class symbol of CoreLocation, CoreMotion, AVFAudio, Contacts, EventKit, +CoreBluetooth or Intents. That is not the iOS result: the class names, +selectors and delegate protocol metadata are still in the binary, and Apple +does not document whether its check reads those. Until an App Store Connect +upload of an app that uses only notifications shows no ITMS-90683, the README +tells apps to expect to need every group's usage description. Leaving groups +out at compile time needs a CLI feature. + +The location strategy keeps one flag in `NSUserDefaults` (whether "always" +was asked for), a required-reason API; the iOS implementation ships a +privacy manifest for the same reason. The README shows the entry an app's +manifest needs. + +watchOS terminates an app that asks for a permission without its usage +description. Before each prompt this package checks the Info.plist key the +prompt needs and fails the request with a `PlatformException` whose code is +`MISSING_USAGE_DESCRIPTION`, the code the iOS implementation uses for +location, instead. + +Each call returns a request id at once; the strategy answers on its own +queue, native keeps the answer as JSON, and wakes Dart through one +`NativeCallable.listener` that carries a kind, never a payload. Dart asks for +the permissions of `requestPermissions` one at a time, as the watch shows one +prompt at a time. + +A location prompt closed without an answer, with the crown, sends no +delegate call on watchOS, not even the second "not determined" report the +iOS implementation takes as that (seen on the watchOS 27.0 Simulator). The +app becoming active again answers then, if it resigned active since the +request (the prompt taking the screen does that): with the status at that +moment, or, if it is still "not determined" a second later, denied. An +answer from the delegate in that second stands the re-read down, so a +request made right after, such as "always" after "when in use", is not +answered by it. + +An "always" location request kept at "while using" changes nothing, so +CoreLocation sends no delegate call. As in the iOS implementation, the app +becoming active again after the prompt (`WKApplicationDidBecomeActiveNotification`) +is the answer then, and a second request answers without a prompt that +watchOS would not show again. + +## Permission coverage + +| Permission | watchOS | +|---|---| +| `notification` | ✅ UNUserNotificationCenter: alert, sound and badge, as on iOS; provisional is reported. The iOS implementation also registers for remote notifications after a grant; this package does not, which is firebase_messaging_watchos's job on the watch | +| `location`, `locationWhenInUse`, `locationAlways` | ✅ CLLocationManager; service status is `locationServicesEnabled` | +| `sensors` | ✅ CMMotionActivityManager, asked for with an activity query as on iOS; service status is `isActivityAvailable` | +| `microphone` | ✅ AVAudioApplication's record permission (watchOS 10 and later) | +| `contacts` | ✅ CNContactStore; the watchOS SDK has no limited access | +| `calendarFullAccess`, `calendarWriteOnly`, `calendar`, `reminders` | ✅ EKEventStore, with the full-access and write-only requests | +| `bluetooth` | ✅ CBCentralManager: creating it asks, its first state update answers; service status is whether it is powered on | +| `criticalAlerts` | ✅ UNUserNotificationCenter's critical alert setting and request; needs the Critical Alerts entitlement | +| `assistant` | ◐ INPreferences (watchOS 6+), Siri, for an app that opts in; needs the Siri capability. INPreferences throws in an app without it (seen on the Simulator), so the Info.plist key `PermissionHandlerWatchosSiri` (`YES`) is the opt-in, in place of the iOS implementation's `PERMISSION_ASSISTANT` macro; `NSSiriUsageDescription`, which apps add with every other group's, does not switch it on. Without the opt-in the status is `denied` and so is a request; with it and no `NSSiriUsageDescription`, a request fails with `MISSING_USAGE_DESCRIPTION`. A per-app compile-time opt-in is #19 | +| `storage` | ✅ granted, service not applicable, as on iOS | +| `camera`, `photos`, `photosAddOnly`, `mediaLibrary`, `speech`, `appTrackingTransparency`, `backgroundRefresh`, `phone` | ✗ not on watchOS: `denied`, a request `permanentlyDenied`, service `disabled`, as iOS answers for an unknown permission | +| The Android-only permissions | answered as an unknown permission, as on iOS | + +## Interface coverage + +| Member | watchOS | +|---|---| +| `checkPermissionStatus` | ✅ | +| `checkServiceStatus` | ✅ | +| `requestPermissions` | ✅ one at a time; another call while one waits fails with `ERROR_ALREADY_REQUESTING_PERMISSIONS`, as on iOS | +| `shouldShowRequestPermissionRationale` | ✅ false, as on iOS | +| `openAppSettings` | ✗ false: watchOS has no settings page an app can open | + +## Example + +`example/lib/main.dart` is permission_handler_apple 9.6.3's own example, +unchanged but for the formatting this repo's CI checks: a phone app on `baseflow_plugin_template` that lists every +permission, shows its status and asks for it on a tap. It runs on the watch, +cramped but usable (on the watchOS 27.0 Simulator a calendar request from it +prompted and answered granted). The example's pubspec adds what it imports, +`baseflow_plugin_template` and `permission_handler_platform_interface`, and +`url_launcher_watchos` for the template's links, which call url_launcher only +when tapped; `res/images/` is upstream's. On the Simulator the template's +info page opened, but its link buttons sit below a scroll area too small to +reach there, so the links were not tapped. The Info.plist has the usage +description of each permission. Upstream has no integration test, so +`integration_test/permission_handler_test.dart` is this package's own; it +imports only `permission_handler`. + +Generated by `flutter-watchos plugin port` on 2026-10-21. + +Source: `permission_handler_apple` 9.6.2 (path: `/Users/iamoguzhanarslantas/.pub-cache/hosted/pub.dev/permission_handler_apple-9.6.2`) +Base platform: ios (Objective-C) +Output: `./permission_handler_watchos` + +## APIs the source plugin used + +### Not available on watchOS + +These iOS/macOS APIs have **no watchOS equivalent** — the capability must be omitted or redesigned (often via the paired iPhone): + +| API | Used at | Why / watchOS note | +|---|---|---| +| AVCaptureCamera | `ios/permission_handler_apple/Sources/permission_handler_apple/strategies/AudioVideoPermissionStrategy.m:58` (+1 more) | AVFoundation exists on watchOS but the capture stack does not — there is no camera. Camera features must be omitted; the rest of the plugin's AVFoundation use (players, audio) can stay. | +| CoreTelephony | `ios/permission_handler_apple/Sources/permission_handler_apple/strategies/PhonePermissionStrategy.m:8` (+6 more) | CoreTelephony is not available on watchOS — even cellular watch models do not expose carrier/cellular-plan APIs to apps. There is no watchOS replacement; the feature must be omitted. | +| Photos | `ios/permission_handler_apple/Sources/permission_handler_apple/strategies/PhotoPermissionStrategy.h:11` (+4 more) | The Photos library framework is not available on watchOS. | +| SpeechRecognition | `ios/permission_handler_apple/Sources/permission_handler_apple/strategies/SpeechPermissionStrategy.m:27` (+2 more) | The Speech framework is not available on watchOS. System dictation is reachable only through WatchKit text input (`presentTextInputController`), which the Flutter watchOS engine already drives for text fields — a custom speech pipeline has no watchOS port. | +| UIApplication | `ios/permission_handler_apple/Sources/permission_handler_apple/strategies/BackgroundRefreshStrategy.m:25` (+4 more) | UIApplication does not exist on watchOS — the app object is WKApplication (watchOS 7+) / WKExtension. For opening URLs, use `openSystemURL(_:)`. It reliably handles tel: and sms:, and — despite the documentation listing only those — it also accepts http/https, presenting the system web sheet. Verified on a physical watch (watchOS 26.5): for a third-party app that sheet declines to render and shows "URL failed to load — this url can be viewed on your iPhone", even for a trivial page. Pair it with an NSUserActivity (NSUserActivityTypeBrowsingWeb) so the phone can actually pick the link up — see url_launcher_watchos. | + +### Available, but review + +These work on watchOS (often differently than iOS) — implement them, checking the note: + +| API | Used at | watchOS note | +|---|---|---| +| CoreLocation | `ios/permission_handler_apple/Sources/permission_handler_apple/strategies/LocationPermissionStrategy.m:17` (+9 more) | CoreLocation IS available on watchOS: requestLocation, continuous updates, and heading (watchOS 6+) work, with GPS on cellular/GPS models and phone-assisted fixes otherwise. Differences to review: authorization is shared with the paired iPhone app when one exists, region monitoring is limited, and background location needs a workout or background-refresh context. | + +## Checklist + +- [x] Declare your C functions in `watchos/Classes/permission_handler_watchos_ffi.h` and implement them in the `.m`, one per platform-interface method you support. +- [x] List every exported symbol under `ffiSymbols` in `pubspec.yaml`, and the frameworks you link in `Package.swift`. +- [x] Add a `lookupFunction` binding per symbol in the Dart `Bindings` class and override the platform-interface methods. +- [x] Add the package to a watchOS app (`flutter-watchos create` one if needed), build for `watchsimulator`, then `nm` the binary to confirm your `ffiSymbols` are present (type `T`). +- [x] Bump the version and update `CHANGELOG.md` before publishing. + +--- + +See the finished plugins in the `flutterwatch/plugins` repo (e.g. `path_provider_watchos`, `battery_plus_watchos`) for worked examples of this exact shape. diff --git a/packages/permission_handler_watchos/README.md b/packages/permission_handler_watchos/README.md new file mode 100644 index 0000000..e6edce5 --- /dev/null +++ b/packages/permission_handler_watchos/README.md @@ -0,0 +1,116 @@ +# permission_handler_watchos + +The watchOS implementation of [`permission_handler`](https://pub.dev/packages/permission_handler). + +Scaffolded with [`flutter-watchos plugin port`](https://github.com/flutterwatch/flutter-watchos) +from `permission_handler_apple` and finished by hand as an **FFI** +implementation — see `PORTING_REPORT.md`. + +## Usage + +`permission_handler` does not include a watchOS implementation, so add this +package alongside it: + +```yaml +dependencies: + permission_handler: ^13.0.2 + permission_handler_watchos: ^0.0.1 +``` + +Use permission_handler as usual: + +```dart +final PermissionStatus status = await Permission.locationWhenInUse.request(); +if (status.isGranted) { + // ... +} +``` + +Add the usage description of each permission you ask for to the watch app's +`watchos/Runner/Info.plist`, as on iOS: `NSLocationWhenInUseUsageDescription`, +`NSLocationAlwaysAndWhenInUseUsageDescription`, `NSMotionUsageDescription`, +`NSMicrophoneUsageDescription`, `NSContactsUsageDescription`, +`NSCalendarsFullAccessUsageDescription`, +`NSCalendarsWriteOnlyAccessUsageDescription`, +`NSRemindersFullAccessUsageDescription`, `NSBluetoothAlwaysUsageDescription`, +`NSSiriUsageDescription`. A request whose key is missing fails with a +`PlatformException` whose code is `MISSING_USAGE_DESCRIPTION`, where watchOS +would terminate the app. Siri also needs its own opt-in, only with the Siri +capability (see `assistant` below), because asking about Siri without the +capability ends the app. + +### App Review + +Every permission group's code is in every app that uses this package. The +iOS implementation leaves a group out at compile time unless its build macro +is set, so App Store Connect sees no privacy API an app does not use. A watch +app has no Podfile to set such macros, and the flutter-watchos CLI compiles +plugin sources with fixed flags. Here the frameworks other than +UserNotifications are not linked and are loaded only when a permission of +their group is asked about, but each group's class names, selectors and +delegate metadata are still in the binary. Whether App Store Connect's check +for missing usage descriptions (ITMS-90683) reads those is not documented, +and no upload has checked it yet: until one has, expect an app to need the +usage description of every group, the ones it never asks for included. + +The location strategy keeps one flag in `NSUserDefaults`, whether "always" +was asked for, since watchOS shows that prompt once. `NSUserDefaults` is a +required-reason API and this code is in every app that uses the package, so +the app's privacy manifest (`PrivacyInfo.xcprivacy`) declares +`NSPrivacyAccessedAPICategoryUserDefaults` with reason `CA92.1`: + +```xml +NSPrivacyAccessedAPITypes + + + NSPrivacyAccessedAPIType + NSPrivacyAccessedAPICategoryUserDefaults + NSPrivacyAccessedAPITypeReasons + + CA92.1 + + + +``` + +## Behaviour on watchOS + +| Permission | watchOS | +|---|---| +| `notification` | supported, provisional included | +| `location`, `locationWhenInUse`, `locationAlways` | supported, with the service status; "always" needs "when in use" first, as on iOS | +| `sensors` | supported (Motion & Fitness), with the service status | +| `microphone` | supported | +| `contacts` | supported; watchOS has no limited access | +| `calendarFullAccess`, `calendarWriteOnly`, `reminders` | supported, with the full-access and write-only prompts | +| `bluetooth` | supported, with the service status | +| `criticalAlerts` | supported; needs the Critical Alerts entitlement (`com.apple.developer.usernotifications.critical-alerts`), which Apple grants on request | +| `assistant` | Siri, supported for an app that opts in: watchOS ends an app without the Siri capability (`com.apple.developer.siri`) that asks about Siri, so the iOS implementation's build macro is an Info.plist key here, `PermissionHandlerWatchosSiri` set to `YES`, which only an app with the capability sets, with `NSSiriUsageDescription`. Without it the status is `denied`, a request too, and Siri is never asked | +| `storage` | granted, as on iOS: the app's own container needs no permission | + +`shouldShowRequestPermissionRationale` is false, as on iOS. The statuses and +the error codes are the iOS implementation's. + +## Not supported on watchOS + +| Member | On watchOS | Why | +|---|---|---| +| `camera`, `photos`, `photosAddOnly`, `mediaLibrary`, `speech`, `appTrackingTransparency`, `backgroundRefresh`, `phone` | `denied`; a request `permanentlyDenied`; service `disabled` | watchOS has none of these; iOS answers the same for a permission it does not know | +| `openAppSettings` | returns false | watchOS has no settings page an app can open; the wearer changes a permission in the watch's Settings or in the Watch app on the iPhone | + +## Example deviations + +The example is `permission_handler_apple`'s own example app, unchanged +except for this watchOS deviation (and the formatting this repository's CI +checks): + +| Where | Change | Why | +|---|---|---| +| `example/pubspec.yaml` | adds `url_launcher_watchos` | the example's `baseflow_plugin_template` opens its links with `url_launcher`, which has no watchOS implementation without it | + +`example/integration_test/permission_handler_test.dart` is this package's +own: upstream has no integration test. + +## License + +MIT, as upstream `permission_handler` is. See `LICENSE` for the full text. diff --git a/packages/permission_handler_watchos/analysis_options.yaml b/packages/permission_handler_watchos/analysis_options.yaml new file mode 100644 index 0000000..d0114d8 --- /dev/null +++ b/packages/permission_handler_watchos/analysis_options.yaml @@ -0,0 +1,9 @@ +include: package:flutter_lints/flutter.yaml + +analyzer: + exclude: + - build/** + language: + strict-casts: true + strict-inference: true + strict-raw-types: true diff --git a/packages/permission_handler_watchos/example/.gitignore b/packages/permission_handler_watchos/example/.gitignore new file mode 100644 index 0000000..3b47c00 --- /dev/null +++ b/packages/permission_handler_watchos/example/.gitignore @@ -0,0 +1,14 @@ +.dart_tool/ +.packages +build/ +.flutter-plugins +.flutter-plugins-dependencies +*.iml +.idea/ +.DS_Store + +# watchOS / CocoaPods +watchos/Pods/ +watchos/Podfile.lock +watchos/.symlinks/ +watchos/Flutter/Flutter.framework diff --git a/packages/permission_handler_watchos/example/README.md b/packages/permission_handler_watchos/example/README.md new file mode 100644 index 0000000..ac2fe02 --- /dev/null +++ b/packages/permission_handler_watchos/example/README.md @@ -0,0 +1,9 @@ +# permission_handler_example + +A watch demo of `permission_handler_watchos`: every permission watchOS has, +with its status. Tapping one asks for it. + +```sh +flutter-watchos run -d +flutter-watchos test integration_test/permission_handler_test.dart -d +``` diff --git a/packages/permission_handler_watchos/example/analysis_options.yaml b/packages/permission_handler_watchos/example/analysis_options.yaml new file mode 100644 index 0000000..801d885 --- /dev/null +++ b/packages/permission_handler_watchos/example/analysis_options.yaml @@ -0,0 +1,4 @@ +analyzer: + exclude: + - build/** +include: package:flutter_lints/flutter.yaml diff --git a/packages/permission_handler_watchos/example/integration_test/permission_handler_test.dart b/packages/permission_handler_watchos/example/integration_test/permission_handler_test.dart new file mode 100644 index 0000000..4e7cd4d --- /dev/null +++ b/packages/permission_handler_watchos/example/integration_test/permission_handler_test.dart @@ -0,0 +1,63 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Against the real watch, through permission_handler's own API: every +// symbol resolves, every permission answers, and the answers that need no +// prompt are the ones the iOS implementation gives. Run it on a Simulator +// with the app installed afresh (flutter-watchos test does that): +// flutter-watchos test integration_test/permission_handler_test.dart \ +// -d + +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:integration_test/integration_test.dart'; +import 'package:permission_handler/permission_handler.dart'; + +void main() { + IntegrationTestWidgetsFlutterBinding.ensureInitialized(); + + testWidgets('every permission answers with a status', (WidgetTester _) async { + for (final Permission permission in Permission.values) { + expect(await permission.status, isA(), + reason: '$permission'); + } + }); + + testWidgets('a permission watchOS lacks answers as on iOS', + (WidgetTester _) async { + expect(await Permission.camera.status, PermissionStatus.denied); + expect( + await Permission.camera.request(), PermissionStatus.permanentlyDenied); + expect(await Permission.phone.serviceStatus, ServiceStatus.disabled); + }); + + testWidgets('storage, critical alerts and Siri answer as on iOS', + (WidgetTester _) async { + expect(await Permission.storage.status, PermissionStatus.granted); + expect(await Permission.storage.request(), PermissionStatus.granted); + // The example has neither the Critical Alerts entitlement nor Siri, so + // neither has been asked for. Its Info.plist has no + // NSSiriUsageDescription, so Siri is not even asked about: INPreferences + // ends an app without the Siri entitlement. + expect(await Permission.criticalAlerts.status, PermissionStatus.denied); + expect(await Permission.assistant.status, PermissionStatus.denied); + }); + + testWidgets('location services answer', (WidgetTester _) async { + expect(await Permission.location.serviceStatus, isA()); + }); + + testWidgets('"always" before "when in use" fails as on iOS', + (WidgetTester _) async { + // Only meaningful on a fresh install, where location is not determined. + if (await Permission.locationWhenInUse.status != PermissionStatus.denied) { + return; + } + await expectLater( + Permission.locationAlways.request(), + throwsA(isA().having((PlatformException e) => e.code, + 'code', 'MISSING_WHENINUSE_PERMISSION')), + ); + }); +} diff --git a/packages/permission_handler_watchos/example/lib/main.dart b/packages/permission_handler_watchos/example/lib/main.dart new file mode 100644 index 0000000..cbcf835 --- /dev/null +++ b/packages/permission_handler_watchos/example/lib/main.dart @@ -0,0 +1,164 @@ +import 'package:baseflow_plugin_template/baseflow_plugin_template.dart'; +import 'package:flutter/material.dart'; +import 'package:permission_handler_platform_interface/permission_handler_platform_interface.dart'; + +void main() { + runApp( + BaseflowPluginExample( + pluginName: 'Permission Handler', + githubURL: 'https://github.com/Baseflow/flutter-permission-handler', + pubDevURL: 'https://pub.dev/packages/permission_handler', + pages: [PermissionHandlerWidget.createPage()], + ), + ); +} + +///Defines the main theme color +final MaterialColor themeMaterialColor = + BaseflowPluginExample.createMaterialColor( + const Color.fromRGBO(48, 49, 60, 1), +); + +/// A Flutter application demonstrating the functionality of this plugin +class PermissionHandlerWidget extends StatefulWidget { + const PermissionHandlerWidget._(); + + /// Create a page containing the functionality of this plugin + static ExamplePage createPage() { + return ExamplePage( + Icons.location_on, + (context) => const PermissionHandlerWidget._(), + ); + } + + @override + PermissionHandlerWidgetState createState() => PermissionHandlerWidgetState(); +} + +/// The state of the [PermissionHandlerWidget] that listens for permission status changes. +class PermissionHandlerWidgetState extends State { + @override + Widget build(BuildContext context) { + return Center( + child: ListView( + children: Permission.values + .where((permission) { + return permission != Permission.unknown && + permission != Permission.phone && + permission != Permission.sms && + permission != Permission.ignoreBatteryOptimizations && + permission != Permission.accessMediaLocation && + permission != Permission.activityRecognition && + permission != Permission.manageExternalStorage && + permission != Permission.systemAlertWindow && + permission != Permission.requestInstallPackages && + permission != Permission.accessNotificationPolicy && + permission != Permission.bluetoothScan && + permission != Permission.bluetoothAdvertise && + permission != Permission.bluetoothConnect && + permission != Permission.nearbyWifiDevices && + permission != Permission.videos && + permission != Permission.audio && + permission != Permission.scheduleExactAlarm && + permission != Permission.sensorsAlways; + }) + .map((permission) => PermissionWidget(permission)) + .toList(), + ), + ); + } +} + +/// Permission widget containing information about the passed [Permission] +class PermissionWidget extends StatefulWidget { + /// Constructs a [PermissionWidget] for the supplied [Permission] + const PermissionWidget(this.permission, {super.key}); + + /// The [Permission] that this widget is rendered for. + final Permission permission; + + @override + State createState() => _PermissionState(); +} + +class _PermissionState extends State { + final PermissionHandlerPlatform _permissionHandler = + PermissionHandlerPlatform.instance; + PermissionStatus _permissionStatus = PermissionStatus.denied; + + @override + void initState() { + super.initState(); + + _listenForPermissionStatus(); + } + + void _listenForPermissionStatus() async { + final status = await _permissionHandler.checkPermissionStatus( + widget.permission, + ); + setState(() => _permissionStatus = status); + } + + Color getPermissionColor() { + switch (_permissionStatus) { + case PermissionStatus.denied: + return Colors.red; + case PermissionStatus.granted: + return Colors.green; + case PermissionStatus.limited: + return Colors.orange; + default: + return Colors.grey; + } + } + + @override + Widget build(BuildContext context) { + return ListTile( + title: Text( + widget.permission.toString(), + style: Theme.of(context).textTheme.bodyLarge, + ), + subtitle: Text( + _permissionStatus.toString(), + style: TextStyle(color: getPermissionColor()), + ), + trailing: (widget.permission is PermissionWithService) + ? IconButton( + icon: const Icon(Icons.info, color: Colors.white), + onPressed: () { + checkServiceStatus( + context, + widget.permission as PermissionWithService, + ); + }, + ) + : null, + onTap: () { + requestPermission(widget.permission); + }, + ); + } + + void checkServiceStatus( + BuildContext context, + PermissionWithService permission, + ) async { + ScaffoldMessenger.of(context).showSnackBar( + SnackBar( + content: Text( + (await _permissionHandler.checkServiceStatus(permission)).toString(), + ), + ), + ); + } + + Future requestPermission(Permission permission) async { + final status = await _permissionHandler.requestPermissions([permission]); + + setState(() { + _permissionStatus = status[permission] ?? PermissionStatus.denied; + }); + } +} diff --git a/packages/permission_handler_watchos/example/pubspec.yaml b/packages/permission_handler_watchos/example/pubspec.yaml new file mode 100644 index 0000000..8d5edf8 --- /dev/null +++ b/packages/permission_handler_watchos/example/pubspec.yaml @@ -0,0 +1,36 @@ +name: permission_handler_example +description: "watchOS example for permission_handler_watchos." +publish_to: 'none' +version: 1.0.0+1 + +environment: + sdk: ">=3.1.0 <4.0.0" + +dependencies: + # lib/ is permission_handler_apple's own example, which imports these two. + baseflow_plugin_template: ^2.2.1 + flutter: + sdk: flutter + permission_handler: ^13.0.2 + permission_handler_platform_interface: ^4.4.1 + permission_handler_watchos: + path: ../ + # The template's links go through url_launcher, which this package + # answers on the watch. + url_launcher_watchos: + path: ../../url_launcher_watchos + +dev_dependencies: + flutter_lints: ^4.0.0 + flutter_test: + sdk: flutter + integration_test: + sdk: flutter + +flutter: + uses-material-design: true + + # The template's logos, as upstream's example lists them. + assets: + - res/images/baseflow_logo_def_light-02.png + - res/images/poweredByBaseflowLogoLight@3x.png diff --git a/packages/permission_handler_watchos/example/res/images/baseflow_logo_def_light-02.png b/packages/permission_handler_watchos/example/res/images/baseflow_logo_def_light-02.png new file mode 100644 index 0000000..85f071f Binary files /dev/null and b/packages/permission_handler_watchos/example/res/images/baseflow_logo_def_light-02.png differ diff --git a/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight.png b/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight.png new file mode 100644 index 0000000..6b9f1aa Binary files /dev/null and b/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight.png differ diff --git a/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight@2x.png b/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight@2x.png new file mode 100644 index 0000000..66901d9 Binary files /dev/null and b/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight@2x.png differ diff --git a/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight@3x.png b/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight@3x.png new file mode 100644 index 0000000..36fbdff Binary files /dev/null and b/packages/permission_handler_watchos/example/res/images/poweredByBaseflowLogoLight@3x.png differ diff --git a/packages/permission_handler_watchos/example/test_driver/integration_test.dart b/packages/permission_handler_watchos/example/test_driver/integration_test.dart new file mode 100644 index 0000000..2acb97e --- /dev/null +++ b/packages/permission_handler_watchos/example/test_driver/integration_test.dart @@ -0,0 +1,4 @@ +// Generated by `flutter-watchos plugin port --include-example`. +import 'package:integration_test/integration_test_driver.dart'; + +Future main() => integrationDriver(); diff --git a/packages/permission_handler_watchos/example/watchos/Flutter/.gitignore b/packages/permission_handler_watchos/example/watchos/Flutter/.gitignore new file mode 100644 index 0000000..196f947 --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/Flutter/.gitignore @@ -0,0 +1,3 @@ +# Build artifacts placed here by `flutter-watchos build` — never commit. +* +!.gitignore diff --git a/packages/permission_handler_watchos/example/watchos/HostApp/Assets.xcassets/AppIcon.appiconset/Contents.json b/packages/permission_handler_watchos/example/watchos/HostApp/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..13613e3 --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/HostApp/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,13 @@ +{ + "images" : [ + { + "idiom" : "universal", + "platform" : "ios", + "size" : "1024x1024" + } + ], + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/packages/permission_handler_watchos/example/watchos/HostApp/Assets.xcassets/Contents.json b/packages/permission_handler_watchos/example/watchos/HostApp/Assets.xcassets/Contents.json new file mode 100644 index 0000000..73c0059 --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/HostApp/Assets.xcassets/Contents.json @@ -0,0 +1,6 @@ +{ + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/packages/permission_handler_watchos/example/watchos/HostApp/Info.plist b/packages/permission_handler_watchos/example/watchos/HostApp/Info.plist new file mode 100644 index 0000000..9312f07 --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/HostApp/Info.plist @@ -0,0 +1,48 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleDisplayName + Permission Handler Example + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + ITSWatchOnlyContainer + + LSApplicationLaunchProhibited + + LSRequiresIPhoneOS + + UIApplicationSceneManifest + + UIApplicationSupportsMultipleScenes + + + UILaunchScreen + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + + diff --git a/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/project.pbxproj b/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/project.pbxproj new file mode 100644 index 0000000..917f1d8 --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,438 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 56; + objects = { + +/* Begin PBXBuildFile section */ + AB0000000000000000000001 /* App.swift in Sources */ = {isa = PBXBuildFile; fileRef = AF0000000000000000000001 /* App.swift */; }; + AB0000000000000000000003 /* Flutter.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = AF0000000000000000000003 /* Flutter.framework */; }; + AB0000000000000000000004 /* Flutter.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = AF0000000000000000000003 /* Flutter.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, ); }; }; + AB0000000000000000000005 /* App.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = AF0000000000000000000004 /* App.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, ); }; }; + AB0000000000000000000006 /* flutter_assets in Resources */ = {isa = PBXBuildFile; fileRef = AF0000000000000000000005 /* flutter_assets */; }; + AB0000000000000000000007 /* icudtl.dat in Resources */ = {isa = PBXBuildFile; fileRef = AF0000000000000000000006 /* icudtl.dat */; }; + AB0000000000000000000008 /* vm_isolate_snapshot.bin in Resources */ = {isa = PBXBuildFile; fileRef = AF000000000000000000000A /* vm_isolate_snapshot.bin */; }; + AB0000000000000000000009 /* isolate_snapshot.bin in Resources */ = {isa = PBXBuildFile; fileRef = AF000000000000000000000B /* isolate_snapshot.bin */; }; + AB0000000000000000000010 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = AF000000000000000000000C /* Assets.xcassets */; }; + CB0000000000000000000002 /* Runner.app in Embed Watch Content */ = {isa = PBXBuildFile; fileRef = AF0000000000000000000007 /* Runner.app */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; }; + CB0000000000000000000003 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = CF0000000000000000000004 /* Assets.xcassets */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + CA0000000000000000000004 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = AA0000000000000000000002 /* Project object */; + proxyType = 1; + remoteGlobalIDString = AA0000000000000000000001; + remoteInfo = Runner; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + AC0000000000000000000001 /* Embed Frameworks */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + AB0000000000000000000004 /* Flutter.framework in Embed Frameworks */, + AB0000000000000000000005 /* App.framework in Embed Frameworks */, + ); + name = "Embed Frameworks"; + runOnlyForDeploymentPostprocessing = 0; + }; + CD0000000000000000000011 /* Embed Watch Content */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = "$(CONTENTS_FOLDER_PATH)/Watch"; + dstSubfolderSpec = 16; + files = ( + CB0000000000000000000002 /* Runner.app in Embed Watch Content */, + ); + name = "Embed Watch Content"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 0B66C03D2FE326E4002C6E54 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + AF0000000000000000000001 /* App.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = App.swift; sourceTree = ""; }; + AF0000000000000000000003 /* Flutter.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = Flutter.framework; sourceTree = ""; }; + AF0000000000000000000004 /* App.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = App.framework; sourceTree = ""; }; + AF0000000000000000000005 /* flutter_assets */ = {isa = PBXFileReference; lastKnownFileType = folder; path = flutter_assets; sourceTree = ""; }; + AF0000000000000000000006 /* icudtl.dat */ = {isa = PBXFileReference; lastKnownFileType = file; path = icudtl.dat; sourceTree = ""; }; + AF0000000000000000000007 /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; }; + AF000000000000000000000A /* vm_isolate_snapshot.bin */ = {isa = PBXFileReference; lastKnownFileType = archive.macbinary; path = vm_isolate_snapshot.bin; sourceTree = ""; }; + AF000000000000000000000B /* isolate_snapshot.bin */ = {isa = PBXFileReference; lastKnownFileType = archive.macbinary; path = isolate_snapshot.bin; sourceTree = ""; }; + AF000000000000000000000C /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + AF000000000000000000000D /* Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = ""; }; + AF000000000000000000000E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = ""; }; + CF0000000000000000000001 /* permission_handler_example.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = permission_handler_example.app; sourceTree = BUILT_PRODUCTS_DIR; }; + CF0000000000000000000003 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + CF0000000000000000000004 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + AD0000000000000000000001 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + AB0000000000000000000003 /* Flutter.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + AE0000000000000000000001 = { + isa = PBXGroup; + children = ( + AE0000000000000000000002 /* Runner */, + CE0000000000000000000001 /* HostApp */, + AE0000000000000000000004 /* Flutter */, + AE0000000000000000000003 /* Products */, + ); + sourceTree = ""; + }; + AE0000000000000000000002 /* Runner */ = { + isa = PBXGroup; + children = ( + AF0000000000000000000001 /* App.swift */, + AF000000000000000000000C /* Assets.xcassets */, + 0B66C03D2FE326E4002C6E54 /* Info.plist */, + ); + path = Runner; + sourceTree = ""; + }; + AE0000000000000000000003 /* Products */ = { + isa = PBXGroup; + children = ( + AF0000000000000000000007 /* Runner.app */, + CF0000000000000000000001 /* permission_handler_example.app */, + ); + name = Products; + sourceTree = ""; + }; + AE0000000000000000000004 /* Flutter */ = { + isa = PBXGroup; + children = ( + AF0000000000000000000003 /* Flutter.framework */, + AF0000000000000000000004 /* App.framework */, + AF0000000000000000000005 /* flutter_assets */, + AF0000000000000000000006 /* icudtl.dat */, + AF000000000000000000000A /* vm_isolate_snapshot.bin */, + AF000000000000000000000B /* isolate_snapshot.bin */, + AF000000000000000000000D /* Debug.xcconfig */, + AF000000000000000000000E /* Release.xcconfig */, + ); + path = Flutter; + sourceTree = ""; + }; + CE0000000000000000000001 /* HostApp */ = { + isa = PBXGroup; + children = ( + CF0000000000000000000004 /* Assets.xcassets */, + CF0000000000000000000003 /* Info.plist */, + ); + path = HostApp; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + AA0000000000000000000001 /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = BA0000000000000000000002 /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + AD0000000000000000000002 /* Sources */, + AD0000000000000000000001 /* Frameworks */, + AD0000000000000000000003 /* Resources */, + AC0000000000000000000001 /* Embed Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = Runner; + productName = Runner; + productReference = AF0000000000000000000007 /* Runner.app */; + productType = "com.apple.product-type.application"; + }; + CA0000000000000000000001 /* HostApp */ = { + isa = PBXNativeTarget; + buildConfigurationList = CA0000000000000000000003 /* Build configuration list for PBXNativeTarget "HostApp" */; + buildPhases = ( + CD0000000000000000000012 /* Resources */, + CD0000000000000000000011 /* Embed Watch Content */, + ); + buildRules = ( + ); + dependencies = ( + CA0000000000000000000002 /* PBXTargetDependency */, + ); + name = HostApp; + productName = permission_handler_example; + productReference = CF0000000000000000000001 /* permission_handler_example.app */; + productType = "com.apple.product-type.application.watchapp2-container"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + AA0000000000000000000002 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = 1; + LastUpgradeCheck = 2700; + TargetAttributes = { + AA0000000000000000000001 = { + CreatedOnToolsVersion = 15.0; + }; + CA0000000000000000000001 = { + CreatedOnToolsVersion = 15.0; + }; + }; + }; + buildConfigurationList = BA0000000000000000000001 /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 14.0"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = AE0000000000000000000001; + productRefGroup = AE0000000000000000000003 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + AA0000000000000000000001 /* Runner */, + CA0000000000000000000001 /* HostApp */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + AD0000000000000000000003 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + AB0000000000000000000006 /* flutter_assets in Resources */, + AB0000000000000000000007 /* icudtl.dat in Resources */, + AB0000000000000000000008 /* vm_isolate_snapshot.bin in Resources */, + AB0000000000000000000009 /* isolate_snapshot.bin in Resources */, + AB0000000000000000000010 /* Assets.xcassets in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + CD0000000000000000000012 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + CB0000000000000000000003 /* Assets.xcassets in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + AD0000000000000000000002 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + AB0000000000000000000001 /* App.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + CA0000000000000000000002 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = AA0000000000000000000001 /* Runner */; + targetProxy = CA0000000000000000000004 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin XCBuildConfiguration section */ + BB0000000000000000000001 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES; + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ENABLE_MODULES = YES; + ENABLE_BITCODE = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + ONLY_ACTIVE_ARCH = YES; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + BB0000000000000000000002 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = AF000000000000000000000D /* Debug.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CODE_SIGN_IDENTITY = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + DEVELOPMENT_TEAM = ""; + FRAMEWORK_SEARCH_PATHS = "$(PROJECT_DIR)/Flutter"; + GENERATE_INFOPLIST_FILE = NO; + HEADER_SEARCH_PATHS = "$(PROJECT_DIR)/Flutter"; + INFOPLIST_FILE = Runner/Info.plist; + INSTALL_PATH = "$(LOCAL_APPS_DIR)"; + LD_RUNPATH_SEARCH_PATHS = "@executable_path/Frameworks"; + LIBRARY_SEARCH_PATHS = "$(PROJECT_DIR)/Flutter"; + MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)"; + PRODUCT_BUNDLE_IDENTIFIER = "com.example.permissionHandlerExample.watchkitapp"; + PRODUCT_NAME = Runner; + SDKROOT = watchos; + SKIP_INSTALL = YES; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = 4; + WATCHOS_DEPLOYMENT_TARGET = 26.0; + }; + name = Debug; + }; + BB0000000000000000000003 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES; + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ENABLE_MODULES = YES; + ENABLE_BITCODE = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = s; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Release; + }; + BB0000000000000000000004 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = AF000000000000000000000E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CODE_SIGN_IDENTITY = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + DEVELOPMENT_TEAM = ""; + FRAMEWORK_SEARCH_PATHS = "$(PROJECT_DIR)/Flutter"; + GENERATE_INFOPLIST_FILE = NO; + HEADER_SEARCH_PATHS = "$(PROJECT_DIR)/Flutter"; + INFOPLIST_FILE = Runner/Info.plist; + INSTALL_PATH = "$(LOCAL_APPS_DIR)"; + LD_RUNPATH_SEARCH_PATHS = "@executable_path/Frameworks"; + LIBRARY_SEARCH_PATHS = "$(PROJECT_DIR)/Flutter"; + MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)"; + PRODUCT_BUNDLE_IDENTIFIER = "com.example.permissionHandlerExample.watchkitapp"; + PRODUCT_NAME = Runner; + SDKROOT = watchos; + SKIP_INSTALL = YES; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = 4; + WATCHOS_DEPLOYMENT_TARGET = 26.0; + }; + name = Release; + }; + CC0000000000000000000001 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = AF000000000000000000000D /* Debug.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_GENERATE_ASSET_SYMBOLS = NO; + CODE_SIGN_IDENTITY = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + DEVELOPMENT_TEAM = ""; + ENABLE_BITCODE = NO; + GENERATE_INFOPLIST_FILE = NO; + INFOPLIST_FILE = HostApp/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 26.0; + LD_RUNPATH_SEARCH_PATHS = "@executable_path/Frameworks"; + MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)"; + PRODUCT_BUNDLE_IDENTIFIER = "com.example.permissionHandlerExample"; + PRODUCT_NAME = permission_handler_example; + SDKROOT = iphoneos; + SKIP_INSTALL = NO; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + CC0000000000000000000002 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = AF000000000000000000000E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_GENERATE_ASSET_SYMBOLS = NO; + CODE_SIGN_IDENTITY = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + DEVELOPMENT_TEAM = ""; + ENABLE_BITCODE = NO; + GENERATE_INFOPLIST_FILE = NO; + INFOPLIST_FILE = HostApp/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 26.0; + LD_RUNPATH_SEARCH_PATHS = "@executable_path/Frameworks"; + MARKETING_VERSION = "$(FLUTTER_BUILD_NAME)"; + PRODUCT_BUNDLE_IDENTIFIER = "com.example.permissionHandlerExample"; + PRODUCT_NAME = permission_handler_example; + SDKROOT = iphoneos; + SKIP_INSTALL = NO; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + BA0000000000000000000001 /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + BB0000000000000000000001 /* Debug */, + BB0000000000000000000003 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + BA0000000000000000000002 /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + BB0000000000000000000002 /* Debug */, + BB0000000000000000000004 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + CA0000000000000000000003 /* Build configuration list for PBXNativeTarget "HostApp" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + CC0000000000000000000001 /* Debug */, + CC0000000000000000000002 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = AA0000000000000000000002 /* Project object */; +} diff --git a/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 0000000..1bc84b8 --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,81 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/xcshareddata/xcschemes/permission_handler_example.xcscheme b/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/xcshareddata/xcschemes/permission_handler_example.xcscheme new file mode 100644 index 0000000..222dae3 --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/Runner.xcodeproj/xcshareddata/xcschemes/permission_handler_example.xcscheme @@ -0,0 +1,77 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/permission_handler_watchos/example/watchos/Runner/App.swift b/packages/permission_handler_watchos/example/watchos/Runner/App.swift new file mode 100644 index 0000000..f2b52dd --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/Runner/App.swift @@ -0,0 +1,57 @@ +import SwiftUI + +#if !arch(arm64_32) +// The Flutter host (frame display, input, native overlays) — compiled by +// flutter-watchos into watchos/Flutter/, like Flutter.framework itself. +import FlutterWatchOS +#endif + +@main +struct PermissionHandlerExampleApp: App { + #if !arch(arm64_32) + // Remote-notification plumbing (APNs device token, notification payloads) + // for plugins that need it, e.g. firebase_messaging. Safe to keep even if + // no plugin uses notifications. + @WKApplicationDelegateAdaptor(FlutterWatchOSAppDelegate.self) + private var flutterAppDelegate + + init() { + // Native platform views: register a SwiftUI factory for every + // `viewType` your Dart code embeds with WatchPlatformView + // (package:flutter_watchos). Example: + // + // WatchPlatformViewRegistry.register("my-gauge") { params in + // AnyView(MyGaugeView(params: params)) + // } + } + #endif + + var body: some Scene { + WindowGroup { + #if arch(arm64_32) + // 32-bit watches (Series 4–8 / SE) are not supported. + UnsupportedDeviceView() + #else + // Holds a black launch placeholder over the screen until Flutter's + // first frame is ready, then fades it out. Supply your own to + // replace it: `FlutterHostView { MyLaunchScreen() }`. + FlutterHostView() + #endif + } + } +} + +// Shown on 32-bit watches (Series 4–8 / SE), which this app does not support. +struct UnsupportedDeviceView: View { + var body: some View { + VStack(spacing: 8) { + Text("Permission Handler Example") + .font(.headline) + Text("Requires Apple Watch Series 9 or later.") + .font(.footnote) + .multilineTextAlignment(.center) + .foregroundStyle(.secondary) + } + .padding() + } +} diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..287d73c --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,140 @@ +{ + "images" : [ + { + "filename" : "icon_24x24_2x_38mm.png", + "idiom" : "watch", + "role" : "notificationCenter", + "scale" : "2x", + "size" : "24x24", + "subtype" : "38mm" + }, + { + "filename" : "icon_27.5x27.5_2x_42mm.png", + "idiom" : "watch", + "role" : "notificationCenter", + "scale" : "2x", + "size" : "27.5x27.5", + "subtype" : "42mm" + }, + { + "filename" : "icon_29x29_2x_companion.png", + "idiom" : "watch", + "role" : "companionSettings", + "scale" : "2x", + "size" : "29x29" + }, + { + "filename" : "icon_29x29_3x_companion.png", + "idiom" : "watch", + "role" : "companionSettings", + "scale" : "3x", + "size" : "29x29" + }, + { + "filename" : "icon_33x33_2x_45mm.png", + "idiom" : "watch", + "role" : "notificationCenter", + "scale" : "2x", + "size" : "33x33", + "subtype" : "45mm" + }, + { + "filename" : "icon_40x40_2x_38mm.png", + "idiom" : "watch", + "role" : "appLauncher", + "scale" : "2x", + "size" : "40x40", + "subtype" : "38mm" + }, + { + "filename" : "icon_44x44_2x_40mm.png", + "idiom" : "watch", + "role" : "appLauncher", + "scale" : "2x", + "size" : "44x44", + "subtype" : "40mm" + }, + { + "filename" : "icon_46x46_2x_41mm.png", + "idiom" : "watch", + "role" : "appLauncher", + "scale" : "2x", + "size" : "46x46", + "subtype" : "41mm" + }, + { + "filename" : "icon_50x50_2x_44mm.png", + "idiom" : "watch", + "role" : "appLauncher", + "scale" : "2x", + "size" : "50x50", + "subtype" : "44mm" + }, + { + "filename" : "icon_51x51_2x_45mm.png", + "idiom" : "watch", + "role" : "appLauncher", + "scale" : "2x", + "size" : "51x51", + "subtype" : "45mm" + }, + { + "filename" : "icon_54x54_2x_49mm.png", + "idiom" : "watch", + "role" : "appLauncher", + "scale" : "2x", + "size" : "54x54", + "subtype" : "49mm" + }, + { + "filename" : "icon_86x86_2x.png", + "idiom" : "watch", + "role" : "quickLook", + "scale" : "2x", + "size" : "86x86", + "subtype" : "38mm" + }, + { + "filename" : "icon_98x98_2x.png", + "idiom" : "watch", + "role" : "quickLook", + "scale" : "2x", + "size" : "98x98", + "subtype" : "42mm" + }, + { + "filename" : "icon_108x108_2x_44mm.png", + "idiom" : "watch", + "role" : "quickLook", + "scale" : "2x", + "size" : "108x108", + "subtype" : "44mm" + }, + { + "filename" : "icon_117x117_2x_45mm.png", + "idiom" : "watch", + "role" : "quickLook", + "scale" : "2x", + "size" : "117x117", + "subtype" : "45mm" + }, + { + "filename" : "icon_129x129_2x_49mm.png", + "idiom" : "watch", + "role" : "quickLook", + "scale" : "2x", + "size" : "129x129", + "subtype" : "49mm" + }, + { + "filename" : "icon_1024.png", + "idiom" : "watch-marketing", + "scale" : "1x", + "size" : "1024x1024" + } + ], + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_1024.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_1024.png new file mode 100644 index 0000000..819d623 Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_1024.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_108x108_2x_44mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_108x108_2x_44mm.png new file mode 100644 index 0000000..7b3140c Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_108x108_2x_44mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_117x117_2x_45mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_117x117_2x_45mm.png new file mode 100644 index 0000000..66f8d8c Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_117x117_2x_45mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_129x129_2x_49mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_129x129_2x_49mm.png new file mode 100644 index 0000000..0382bad Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_129x129_2x_49mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_24x24_2x_38mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_24x24_2x_38mm.png new file mode 100644 index 0000000..14682e5 Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_24x24_2x_38mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_27.5x27.5_2x_42mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_27.5x27.5_2x_42mm.png new file mode 100644 index 0000000..e29fe11 Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_27.5x27.5_2x_42mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_29x29_2x_companion.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_29x29_2x_companion.png new file mode 100644 index 0000000..796aa3f Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_29x29_2x_companion.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_29x29_3x_companion.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_29x29_3x_companion.png new file mode 100644 index 0000000..afbe411 Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_29x29_3x_companion.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_33x33_2x_45mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_33x33_2x_45mm.png new file mode 100644 index 0000000..c24aca9 Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_33x33_2x_45mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_40x40_2x_38mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_40x40_2x_38mm.png new file mode 100644 index 0000000..011934e Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_40x40_2x_38mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_44x44_2x_40mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_44x44_2x_40mm.png new file mode 100644 index 0000000..ec54e61 Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_44x44_2x_40mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_46x46_2x_41mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_46x46_2x_41mm.png new file mode 100644 index 0000000..d574b52 Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_46x46_2x_41mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_50x50_2x_44mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_50x50_2x_44mm.png new file mode 100644 index 0000000..fafa3ef Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_50x50_2x_44mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_51x51_2x_45mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_51x51_2x_45mm.png new file mode 100644 index 0000000..883c37b Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_51x51_2x_45mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_54x54_2x_49mm.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_54x54_2x_49mm.png new file mode 100644 index 0000000..457d76a Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_54x54_2x_49mm.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_86x86_2x.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_86x86_2x.png new file mode 100644 index 0000000..28feaed Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_86x86_2x.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_98x98_2x.png b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_98x98_2x.png new file mode 100644 index 0000000..3b901e5 Binary files /dev/null and b/packages/permission_handler_watchos/example/watchos/Runner/Assets.xcassets/AppIcon.appiconset/icon_98x98_2x.png differ diff --git a/packages/permission_handler_watchos/example/watchos/Runner/Info.plist b/packages/permission_handler_watchos/example/watchos/Runner/Info.plist new file mode 100644 index 0000000..e4c2592 --- /dev/null +++ b/packages/permission_handler_watchos/example/watchos/Runner/Info.plist @@ -0,0 +1,46 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleDisplayName + Permission Handler Example + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + permission_handler_example + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + WKApplication + + NSLocationWhenInUseUsageDescription + The example shows the location permission's status and asks for it. + NSLocationAlwaysAndWhenInUseUsageDescription + The example shows the always-location permission's status and asks for it. + NSMotionUsageDescription + The example shows the Motion & Fitness permission's status and asks for it. + NSMicrophoneUsageDescription + The example shows the microphone permission's status and asks for it. + NSContactsUsageDescription + The example shows the contacts permission's status and asks for it. + NSCalendarsFullAccessUsageDescription + The example shows the calendar permission's status and asks for it. + NSCalendarsWriteOnlyAccessUsageDescription + The example shows the write-only calendar permission's status and asks for it. + NSRemindersFullAccessUsageDescription + The example shows the reminders permission's status and asks for it. + NSBluetoothAlwaysUsageDescription + The example shows the Bluetooth permission's status and asks for it. + WKWatchOnly + + + diff --git a/packages/permission_handler_watchos/lib/permission_handler_watchos.dart b/packages/permission_handler_watchos/lib/permission_handler_watchos.dart new file mode 100644 index 0000000..0cb907c --- /dev/null +++ b/packages/permission_handler_watchos/lib/permission_handler_watchos.dart @@ -0,0 +1,177 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// watchOS implementation of `permission_handler`, over dart:ffi. +// +// Method-channel plugins are not supported on watchOS, so the answers come +// from `watchos/Classes/` over dart:ffi: each call returns a request id, +// native wakes Dart through one `NativeCallable.listener` when an answer is +// ready, and Dart takes it as JSON. The permissions, statuses and error +// codes are the iOS implementation's. + +import 'dart:async'; +import 'dart:convert'; + +import 'package:flutter/services.dart'; +import 'package:permission_handler_platform_interface/permission_handler_platform_interface.dart'; + +import 'src/backend.dart'; +import 'src/ffi_backend.dart'; + +export 'src/backend.dart' show PermissionHandlerWatchosBackend; + +/// What woke Dart up. Mirrored in +/// `watchos/Classes/permission_handler_watchos_ffi.h`. +abstract final class PermissionHandlerWatchosSignal { + /// An answer is ready. + static const int result = 1; +} + +/// watchOS implementation of [PermissionHandlerPlatform]. +/// +/// Answers for location (when in use and always), notifications, critical +/// alerts, sensors (Motion & Fitness), the microphone, contacts, the calendar +/// (full access and write only), reminders, Bluetooth, Siri +/// ([Permission.assistant]) and storage, which is granted as on iOS. The +/// permissions watchOS does not have answer as the iOS implementation +/// answers for one it does not know: [PermissionStatus.denied], a request +/// [PermissionStatus.permanentlyDenied], their service +/// [ServiceStatus.disabled]. +class PermissionHandlerWatchos extends PermissionHandlerPlatform { + /// Test hook: set before first use to replace the native backend. + static PermissionHandlerWatchosBackend? backendOverride; + + static PermissionHandlerWatchosBackend? _backend; + + PermissionHandlerWatchosBackend get _b => + backendOverride ?? (_backend ??= FfiPermissionHandlerWatchosBackend()); + + /// Registers this class as the `permission_handler` implementation on + /// watchOS. + static void registerWith() { + PermissionHandlerPlatform.instance = PermissionHandlerWatchos(); + } + + final Map>> _pending = + >>{}; + bool _registered = false; + bool _requesting = false; + + @override + Future checkPermissionStatus(Permission permission) async => + PermissionStatusValue.statusByValue( + _number(await _await(_b.check(permission.value)), 'status'), + ); + + /// Whether the service behind [permission] is on: location services for + /// the location permissions, motion activity for [Permission.sensors], + /// Bluetooth for [Permission.bluetooth]; [ServiceStatus.notApplicable] for + /// the others watchOS has. + @override + Future checkServiceStatus(Permission permission) async => + ServiceStatusValue.statusByValue( + _number(await _await(_b.service(permission.value)), 'service'), + ); + + /// Asks for each of [permissions] in turn, as the watch shows one prompt + /// at a time, and answers with each one's status afterwards. + /// + /// Fails with a [PlatformException] whose code is + /// `MISSING_USAGE_DESCRIPTION` when the app's Info.plist lacks the key a + /// prompt needs, where watchOS would terminate the app, + /// `MISSING_WHENINUSE_PERMISSION` for [Permission.locationAlways] asked + /// for before "when in use" was granted, and, as on iOS, + /// `ERROR_ALREADY_REQUESTING_PERMISSIONS` while an earlier request is + /// still waiting for its answers. + @override + Future> requestPermissions( + List permissions, + ) async { + if (_requesting) { + throw PlatformException( + code: 'ERROR_ALREADY_REQUESTING_PERMISSIONS', + message: 'A request for permissions is already running, please wait ' + 'for it to finish before doing another request (note that you ' + 'can request multiple permissions at the same time).', + ); + } + _requesting = true; + try { + final Map statuses = + {}; + for (final Permission permission in permissions) { + statuses[permission] = PermissionStatusValue.statusByValue( + _number(await _await(_b.request(permission.value)), 'status'), + ); + } + return statuses; + } finally { + _requesting = false; + } + } + + /// Always false: watchOS, like iOS, has no rationale to show. + @override + Future shouldShowRequestPermissionRationale( + Permission permission, + ) async => + false; + + /// Always false: watchOS has no settings page an app can open. The wearer + /// changes a permission in the watch's Settings, or in the Watch app on + /// the iPhone. + @override + Future openAppSettings() async => false; + + static int _number(Map answer, String key) => + (answer[key]! as num).toInt(); + + void _update() { + final bool wanted = _pending.isNotEmpty; + if (wanted == _registered) { + return; + } + _registered = wanted; + _b.setSignalHandler(wanted + ? (int kind) { + if (kind == PermissionHandlerWatchosSignal.result) { + _drain(); + } + } + : null); + } + + Future> _await(int request) { + final Completer> completer = + Completer>(); + _pending[request] = completer; + _update(); + // The answer may have landed before the handler was registered. + _drain(); + return completer.future; + } + + void _drain() { + for (final int request in _pending.keys.toList()) { + final String? json = _b.takeResult(request); + if (json == null) { + continue; + } + final Completer> completer = + _pending.remove(request)!; + final Map answer = + (jsonDecode(json) as Map).cast(); + final Object? error = answer['error']; + if (error is Map) { + completer.completeError(PlatformException( + code: error['code'] as String? ?? 'ERROR', + message: error['message'] as String?, + )); + } else { + completer.complete(answer); + } + } + _update(); + } +} diff --git a/packages/permission_handler_watchos/lib/src/backend.dart b/packages/permission_handler_watchos/lib/src/backend.dart new file mode 100644 index 0000000..3d65130 --- /dev/null +++ b/packages/permission_handler_watchos/lib/src/backend.dart @@ -0,0 +1,31 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. + +/// The native half of [PermissionHandlerWatchos], behind an interface so +/// host tests can substitute a fake. Every member maps to one exported C +/// function of `watchos/Classes/permission_handler_watchos_ffi.h`. +library; + +import '../permission_handler_watchos.dart'; + +/// See the library documentation. +abstract class PermissionHandlerWatchosBackend { + /// Reads the status of the permission numbered [permission]; returns the + /// request id its answer comes under. + int check(int permission); + + /// Reads whether the service behind [permission] is on; returns the + /// request id. + int service(int permission); + + /// Asks the wearer for [permission] when they have not answered yet; + /// returns the request id. + int request(int permission); + + /// The answer to [request] as JSON, or null while there is none yet. + String? takeResult(int request); + + /// The function native wakes when an answer is ready, or null to stop. + void setSignalHandler(void Function(int kind)? handler); +} diff --git a/packages/permission_handler_watchos/lib/src/ffi_backend.dart b/packages/permission_handler_watchos/lib/src/ffi_backend.dart new file mode 100644 index 0000000..3c9b496 --- /dev/null +++ b/packages/permission_handler_watchos/lib/src/ffi_backend.dart @@ -0,0 +1,88 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// The C symbols of `watchos/Classes/permission_handler_watchos_ffi.h`, +// resolved from the process. + +import 'dart:ffi'; + +import 'package:ffi/ffi.dart'; + +import 'backend.dart'; + +typedef _SignalNative = Void Function(Int64); + +/// [PermissionHandlerWatchosBackend] over the exported C functions. +class FfiPermissionHandlerWatchosBackend + implements PermissionHandlerWatchosBackend { + /// Resolves the symbols from the process lazily, on first use. + FfiPermissionHandlerWatchosBackend() : _lib = DynamicLibrary.process(); + + final DynamicLibrary _lib; + + /// One trampoline for the life of the backend; only its pointer is + /// unregistered, since a [NativeCallable] is reclaimed only by `close()`. + NativeCallable<_SignalNative>? _callable; + void Function(int kind)? _handler; + + late final void Function(Pointer>) + _setCallback = _lib.lookupFunction< + Void Function(Pointer>), + void Function(Pointer>)>( + 'permission_handler_watchos_set_callback'); + late final int Function(int) _check = + _lib.lookupFunction( + 'permission_handler_watchos_check'); + late final int Function(int) _service = + _lib.lookupFunction( + 'permission_handler_watchos_service'); + late final int Function(int) _request = + _lib.lookupFunction( + 'permission_handler_watchos_request'); + late final Pointer Function(int) _takeResult = _lib.lookupFunction< + Pointer Function(Int64), + Pointer Function(int)>('permission_handler_watchos_take_result'); + late final void Function(Pointer) _release = _lib.lookupFunction< + Void Function(Pointer), + void Function(Pointer)>('permission_handler_watchos_release'); + + @override + int check(int permission) => _check(permission); + + @override + int service(int permission) => _service(permission); + + @override + int request(int permission) => _request(permission); + + @override + String? takeResult(int request) { + final Pointer json = _takeResult(request); + if (json == nullptr) { + return null; + } + try { + return json.toDartString(); + } finally { + _release(json); + } + } + + @override + void setSignalHandler(void Function(int kind)? handler) { + _handler = handler; + if (handler == null) { + _setCallback(nullptr); + return; + } + final NativeCallable<_SignalNative> callable = _callable ??= () { + final NativeCallable<_SignalNative> created = + NativeCallable<_SignalNative>.listener( + (int kind) => _handler?.call(kind)); + created.keepIsolateAlive = false; + return created; + }(); + _setCallback(callable.nativeFunction); + } +} diff --git a/packages/permission_handler_watchos/pubspec.yaml b/packages/permission_handler_watchos/pubspec.yaml new file mode 100644 index 0000000..215b0ae --- /dev/null +++ b/packages/permission_handler_watchos/pubspec.yaml @@ -0,0 +1,52 @@ +name: permission_handler_watchos +description: "watchOS implementation of the permission_handler plugin: location, notifications, sensors, microphone, contacts, calendar, reminders and Bluetooth via dart:ffi." +version: 0.0.1 +homepage: https://flutterwatch.dev +repository: https://github.com/flutterwatch/plugins/tree/main/packages/permission_handler_watchos +issue_tracker: https://github.com/flutterwatch/plugins/issues +topics: + - watchos + - ffi + - permissions +# Generated by `flutter-watchos plugin port`. See PORTING_REPORT.md. +# License holder: The FlutterWatch Authors + +environment: + # 3.1 is where NativeCallable.listener landed, which the answers come + # through. + sdk: ">=3.1.0 <4.0.0" + flutter: ">=3.13.0" + +dependencies: + ffi: ^2.1.0 + flutter: + sdk: flutter + permission_handler_platform_interface: ^4.4.0 + +dev_dependencies: + flutter_lints: ^4.0.0 + flutter_test: + sdk: flutter + +flutter: + plugin: + implements: permission_handler + platforms: + watchos: + # FFI plugin: the CLI compiles watchos/Classes/*.m into a + # static archive force-loaded into the watch binary; Dart + # resolves the exported symbols via DynamicLibrary.process(). + # Method-channel plugins are not supported on watchOS, + # so this is the supported plugin model. + ffiPlugin: true + dartPluginClass: PermissionHandlerWatchos + # C symbols exported for dart:ffi lookup. They survive the + # static link because the CLI force-loads the plugin archive + # and each export is marked used + default-visibility. + ffiSymbols: + - permission_handler_watchos_set_callback + - permission_handler_watchos_check + - permission_handler_watchos_service + - permission_handler_watchos_request + - permission_handler_watchos_take_result + - permission_handler_watchos_release diff --git a/packages/permission_handler_watchos/test/permission_handler_watchos_test.dart b/packages/permission_handler_watchos/test/permission_handler_watchos_test.dart new file mode 100644 index 0000000..80d2d61 --- /dev/null +++ b/packages/permission_handler_watchos/test/permission_handler_watchos_test.dart @@ -0,0 +1,199 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Host-side unit tests. The native side is replaced with a fake that answers +// as the header documents, asynchronously as the system does, so the +// request-id round trip, the statuses and the errors are checked off-device. + +import 'dart:async'; +import 'dart:convert'; + +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:permission_handler_platform_interface/permission_handler_platform_interface.dart'; +import 'package:permission_handler_watchos/permission_handler_watchos.dart'; + +class _FakeBackend implements PermissionHandlerWatchosBackend { + /// The status each permission number answers with. + final Map statuses = {}; + + /// The status a request moves each permission number to. + final Map grantedOnRequest = {}; + + /// The error a request of a permission number fails with. + final Map> errors = >{}; + + /// The service status of each permission number. + final Map services = {}; + + final List calls = []; + final Map _results = {}; + void Function(int kind)? _handler; + int _next = 1; + + /// How many requests are being answered at this moment. + int inFlight = 0; + int mostInFlight = 0; + + /// Whether answers land before the call returns, without a signal, as one + /// can before Dart has registered its handler. + bool answerAtOnce = false; + + bool get isRegistered => _handler != null; + + int _answerLater(Object? answer) { + final int id = _next++; + if (answerAtOnce) { + _results[id] = answer; + return id; + } + inFlight++; + mostInFlight = inFlight > mostInFlight ? inFlight : mostInFlight; + scheduleMicrotask(() { + inFlight--; + _results[id] = answer; + _handler?.call(PermissionHandlerWatchosSignal.result); + }); + return id; + } + + @override + int check(int permission) { + calls.add('check $permission'); + return _answerLater({'status': statuses[permission] ?? 0}); + } + + @override + int service(int permission) { + calls.add('service $permission'); + return _answerLater( + {'service': services[permission] ?? 2}); + } + + @override + int request(int permission) { + calls.add('request $permission'); + final Map? error = errors[permission]; + if (error != null) { + return _answerLater({'error': error}); + } + statuses[permission] = grantedOnRequest[permission] ?? 4; + return _answerLater({'status': statuses[permission]}); + } + + @override + String? takeResult(int request) => _results.containsKey(request) + ? jsonEncode(_results.remove(request)) + : null; + + @override + void setSignalHandler(void Function(int kind)? handler) => _handler = handler; +} + +void main() { + late _FakeBackend fake; + late PermissionHandlerPlatform handler; + + setUp(() { + fake = _FakeBackend(); + PermissionHandlerWatchos.backendOverride = fake; + PermissionHandlerWatchos.registerWith(); + handler = PermissionHandlerPlatform.instance; + }); + + tearDown(() => PermissionHandlerWatchos.backendOverride = null); + + test('registerWith installs the watchOS implementation', () { + expect(handler, isA()); + }); + + test('a status is read by the permission\'s number', () async { + fake.statuses[Permission.locationWhenInUse.value] = 1; + fake.statuses[Permission.notification.value] = 5; + fake.statuses[Permission.contacts.value] = 3; + expect(await handler.checkPermissionStatus(Permission.locationWhenInUse), + PermissionStatus.granted); + expect(await handler.checkPermissionStatus(Permission.notification), + PermissionStatus.provisional); + expect(await handler.checkPermissionStatus(Permission.contacts), + PermissionStatus.limited); + expect(fake.isRegistered, isFalse, reason: 'nothing waits any more'); + }); + + test('a service status is read', () async { + fake.services[Permission.location.value] = 1; + fake.services[Permission.bluetooth.value] = 0; + expect(await handler.checkServiceStatus(Permission.location), + ServiceStatus.enabled); + expect(await handler.checkServiceStatus(Permission.bluetooth), + ServiceStatus.disabled); + expect(await handler.checkServiceStatus(Permission.microphone), + ServiceStatus.notApplicable); + }); + + test('permissions are asked for one at a time, in order', () async { + fake.grantedOnRequest[Permission.notification.value] = 1; + final Map statuses = + await handler.requestPermissions([ + Permission.notification, + Permission.camera, + ]); + expect(statuses, { + Permission.notification: PermissionStatus.granted, + Permission.camera: PermissionStatus.permanentlyDenied, + }); + expect(fake.calls, [ + 'request ${Permission.notification.value}', + 'request ${Permission.camera.value}', + ]); + expect(fake.mostInFlight, 1); + }); + + test('a missing usage description is a PlatformException', () async { + fake.errors[Permission.contacts.value] = { + 'code': 'MISSING_USAGE_DESCRIPTION', + 'message': 'The app has no NSContactsUsageDescription.', + }; + await expectLater( + handler.requestPermissions([Permission.contacts]), + throwsA(isA().having((PlatformException e) => e.code, + 'code', 'MISSING_USAGE_DESCRIPTION')), + ); + expect(fake.isRegistered, isFalse); + }); + + test('the watch shows no rationale and opens no settings', () async { + expect( + await handler.shouldShowRequestPermissionRationale(Permission.location), + isFalse); + expect(await handler.openAppSettings(), isFalse); + expect(fake.calls, isEmpty); + }); + + test('a second request while one waits fails as on iOS', () async { + final Future> first = + handler.requestPermissions([Permission.contacts]); + await expectLater( + handler.requestPermissions([Permission.microphone]), + throwsA(isA().having((PlatformException e) => e.code, + 'code', 'ERROR_ALREADY_REQUESTING_PERMISSIONS')), + ); + expect( + (await first)[Permission.contacts], PermissionStatus.permanentlyDenied); + expect( + await handler.requestPermissions([Permission.microphone]), + { + Permission.microphone: PermissionStatus.permanentlyDenied, + }); + }); + + test('an answer that lands before the handler is registered is kept', + () async { + fake.answerAtOnce = true; + fake.statuses[Permission.notification.value] = 1; + expect(await handler.checkPermissionStatus(Permission.notification), + PermissionStatus.granted); + expect(fake.isRegistered, isFalse); + }); +} diff --git a/packages/permission_handler_watchos/watchos/Classes/permission_handler_watchos_ffi.h b/packages/permission_handler_watchos/watchos/Classes/permission_handler_watchos_ffi.h new file mode 100644 index 0000000..2ccd502 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/permission_handler_watchos_ffi.h @@ -0,0 +1,63 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// watchOS implementation of `permission_handler`, over dart:ffi. +// +// A permission is permission_handler's own number for it (the index of the +// Permission in permission_handler_platform_interface), and a status is its +// PermissionStatus or ServiceStatus number, the same numbers the iOS +// implementation answers with. Each call returns a request id at once; the +// answer is kept as JSON until Dart takes it, and native wakes Dart through +// one callback that carries a kind, never a payload. +// +// The answer is {"status": }, {"service": } +// or {"error": {"code", "message"}}. An error's code is the iOS +// implementation's: MISSING_USAGE_DESCRIPTION when the Info.plist lacks the +// key the system prompt needs (the call fails instead of the app being +// terminated), and MISSING_WHENINUSE_PERMISSION for an "always" location +// request made before "when in use" was granted. + +#ifndef PERMISSION_HANDLER_WATCHOS_FFI_H +#define PERMISSION_HANDLER_WATCHOS_FFI_H + +#include + +// Each exported symbol is marked `used` + default-visibility so it survives +// the linker's `-dead_strip` and lands in the executable's dynamic symbol +// table, where `DynamicLibrary.process()` / dlsym can resolve it. +#define PHW_EXPORT __attribute__((visibility("default"))) __attribute__((used)) + +// What woke Dart up. Mirrored in lib/src/ffi_backend.dart. +#define PHW_SIGNAL_RESULT 1 + +typedef void (*phw_signal_callback)(int64_t kind); + +// Registers the callback Dart wants woken, or NULL to stop signalling. +PHW_EXPORT +void permission_handler_watchos_set_callback(phw_signal_callback callback); + +// Reads the status of `permission`, without asking the wearer. +PHW_EXPORT +int64_t permission_handler_watchos_check(int32_t permission); + +// Reads whether the service behind `permission` is on: location services, +// motion activity, Bluetooth; not applicable for the others. +PHW_EXPORT +int64_t permission_handler_watchos_service(int32_t permission); + +// Asks the wearer for `permission` when they have not answered yet, and +// answers with its status afterwards. +PHW_EXPORT +int64_t permission_handler_watchos_request(int32_t permission); + +// The answer to `request` as JSON, which the caller releases with +// permission_handler_watchos_release; NULL while there is none yet. +PHW_EXPORT +char* permission_handler_watchos_take_result(int64_t request); + +// Releases a string this file returned. +PHW_EXPORT +void permission_handler_watchos_release(char* string); + +#endif // PERMISSION_HANDLER_WATCHOS_FFI_H diff --git a/packages/permission_handler_watchos/watchos/Classes/permission_handler_watchos_ffi.m b/packages/permission_handler_watchos/watchos/Classes/permission_handler_watchos_ffi.m new file mode 100644 index 0000000..2078c9a --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/permission_handler_watchos_ffi.m @@ -0,0 +1,260 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// The FFI surface, the answers kept for Dart, and the table of strategies. +// See the header for the contract. + +#import "permission_handler_watchos_ffi.h" +#import "phw_internal.h" + +#import +#import +#import +#import +#import + +static os_unfair_lock _lock = OS_UNFAIR_LOCK_INIT; +static phw_signal_callback _callback = NULL; +static NSMutableDictionary* _results = nil; +// Requests that were answered, so a second answer to one is dropped. +static NSMutableSet* _answered = nil; +static int64_t _nextRequest = 1; + +// ---- Shared helpers --------------------------------------------------------- + +Class phw_class(NSString* framework, NSString* className) { + Class cls = NSClassFromString(className); + if (cls == nil) { + NSString* path = [NSString + stringWithFormat:@"/System/Library/Frameworks/%@.framework/%@", framework, + framework]; + dlopen(path.fileSystemRepresentation, RTLD_LAZY); + cls = NSClassFromString(className); + } + return cls; +} + +BOOL phw_has_key(NSString* key) { + return [[NSBundle mainBundle] objectForInfoDictionaryKey:key] != nil; +} + +void phw_missing_key(NSString* key, PHWErrorHandler failed) { + failed(@"MISSING_USAGE_DESCRIPTION", + [NSString stringWithFormat:@"The app's Info.plist has no %@, which the system " + @"prompt for this permission needs.", + key]); +} + +NSInteger phw_class_integer(Class cls, SEL selector) { + return ((NSInteger (*)(Class, SEL))objc_msgSend)(cls, selector); +} + +NSInteger phw_class_integer_with(Class cls, SEL selector, NSInteger argument) { + return ((NSInteger (*)(Class, SEL, NSInteger))objc_msgSend)(cls, selector, argument); +} + +BOOL phw_class_bool(Class cls, SEL selector) { + return ((BOOL (*)(Class, SEL))objc_msgSend)(cls, selector); +} + +// ---- Answers ---------------------------------------------------------------- + +static char* _json(id object) { + NSData* data = [NSJSONSerialization dataWithJSONObject:object options:0 error:nil]; + if (data == nil) { + return NULL; + } + char* out = malloc(data.length + 1); + if (out == NULL) { + return NULL; + } + memcpy(out, data.bytes, data.length); + out[data.length] = '\0'; + return out; +} + +static int64_t _newRequest(void) { + os_unfair_lock_lock(&_lock); + int64_t request = _nextRequest++; + os_unfair_lock_unlock(&_lock); + return request; +} + +static void _answer(int64_t request, NSDictionary* answer) { + os_unfair_lock_lock(&_lock); + if (_results == nil) { + _results = [NSMutableDictionary dictionary]; + _answered = [NSMutableSet set]; + } + BOOL first = ![_answered containsObject:@(request)]; + if (first) { + [_answered addObject:@(request)]; + _results[@(request)] = answer; + } + phw_signal_callback callback = _callback; + os_unfair_lock_unlock(&_lock); + if (first && callback != NULL) { + callback(PHW_SIGNAL_RESULT); + } +} + +static PHWErrorHandler _failer(int64_t request) { + return ^(NSString* code, NSString* message) { + _answer(request, @{@"error" : @{@"code" : code, @"message" : message}}); + }; +} + +// ---- Strategies ------------------------------------------------------------- + +// Main queue only. +static id _strategy(int32_t permission) { + static NSMutableDictionary>* strategies; + if (strategies == nil) { + strategies = [NSMutableDictionary dictionary]; + } + Class kind; + switch ((PHWPermission)permission) { + case PHWPermissionNotification: + kind = [PHWNotificationStrategy class]; + break; + case PHWPermissionLocation: + case PHWPermissionLocationAlways: + case PHWPermissionLocationWhenInUse: + kind = [PHWLocationStrategy class]; + break; + case PHWPermissionSensors: + kind = [PHWMotionStrategy class]; + break; + case PHWPermissionMicrophone: + kind = [PHWMicrophoneStrategy class]; + break; + case PHWPermissionContacts: + kind = [PHWContactsStrategy class]; + break; + case PHWPermissionCalendar: + case PHWPermissionCalendarWriteOnly: + case PHWPermissionCalendarFullAccess: + case PHWPermissionReminders: + kind = [PHWEventsStrategy class]; + break; + case PHWPermissionBluetooth: + kind = [PHWBluetoothStrategy class]; + break; + case PHWPermissionStorage: + kind = [PHWStorageStrategy class]; + break; + case PHWPermissionCriticalAlerts: + kind = [PHWCriticalAlertsStrategy class]; + break; + case PHWPermissionAssistant: + kind = [PHWAssistantStrategy class]; + break; + default: + kind = [PHWUnknownStrategy class]; + break; + } + NSString* name = NSStringFromClass(kind); + id strategy = strategies[name]; + if (strategy == nil) { + strategy = [[kind alloc] init]; + strategies[name] = strategy; + } + return strategy; +} + +@implementation PHWUnknownStrategy + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + done(PHWStatusDenied); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + done(PHWServiceDisabled); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + done(PHWStatusPermanentlyDenied); +} + +@end + +@implementation PHWStorageStrategy + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + done(PHWStatusGranted); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + done(PHWServiceNotApplicable); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + done(PHWStatusGranted); +} + +@end + +// ---- FFI -------------------------------------------------------------------- + +void permission_handler_watchos_set_callback(phw_signal_callback callback) { + os_unfair_lock_lock(&_lock); + _callback = callback; + os_unfair_lock_unlock(&_lock); +} + +int64_t permission_handler_watchos_check(int32_t permission) { + int64_t request = _newRequest(); + dispatch_async(dispatch_get_main_queue(), ^{ + [_strategy(permission) checkPermission:(PHWPermission)permission + done:^(PHWStatus status) { + _answer(request, @{@"status" : @(status)}); + }]; + }); + return request; +} + +int64_t permission_handler_watchos_service(int32_t permission) { + int64_t request = _newRequest(); + dispatch_async(dispatch_get_main_queue(), ^{ + [_strategy(permission) checkService:(PHWPermission)permission + done:^(PHWService service) { + _answer(request, @{@"service" : @(service)}); + } + failed:_failer(request)]; + }); + return request; +} + +int64_t permission_handler_watchos_request(int32_t permission) { + int64_t request = _newRequest(); + dispatch_async(dispatch_get_main_queue(), ^{ + [_strategy(permission) requestPermission:(PHWPermission)permission + done:^(PHWStatus status) { + _answer(request, @{@"status" : @(status)}); + } + failed:_failer(request)]; + }); + return request; +} + +char* permission_handler_watchos_take_result(int64_t request) { + os_unfair_lock_lock(&_lock); + NSDictionary* result = _results[@(request)]; + [_results removeObjectForKey:@(request)]; + [_answered removeObject:@(request)]; + os_unfair_lock_unlock(&_lock); + return result == nil ? NULL : _json(result); +} + +void permission_handler_watchos_release(char* string) { + free(string); +} diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_assistant.m b/packages/permission_handler_watchos/watchos/Classes/phw_assistant.m new file mode 100644 index 0000000..65abf46 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_assistant.m @@ -0,0 +1,91 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Siri, through INPreferences (watchOS 6 and later), answered as the iOS +// implementation answers it. Intents is loaded at runtime and only messaged. +// +// INPreferences throws, ending the app, in a process without the Siri +// entitlement, and the exception leaves its dispatch_once unfinished, so it +// cannot be caught and asked again. The iOS implementation only compiles this +// in when the app sets PERMISSION_ASSISTANT. Here the opt-in is the +// Info.plist key below, set to YES, which an app adds only with the Siri +// capability; a usage description alone does not switch it on, since apps +// are told to add every group's. Without the opt-in, Siri is never asked +// about: the status is denied, and so is a request. + +#import "phw_internal.h" + +#import +#import + +// The Info.plist key, a Boolean, that says the app has the Siri capability. +static NSString* const kSiriOptIn = @"PermissionHandlerWatchosSiri"; + +static BOOL _optedIn(void) { + id value = [[NSBundle mainBundle] objectForInfoDictionaryKey:kSiriOptIn]; + return [value isKindOfClass:[NSNumber class]] && [value boolValue]; +} + +static PHWStatus _assistantStatus(NSInteger status) { + switch ((INSiriAuthorizationStatus)status) { + case INSiriAuthorizationStatusAuthorized: + return PHWStatusGranted; + case INSiriAuthorizationStatusRestricted: + return PHWStatusRestricted; + case INSiriAuthorizationStatusDenied: + return PHWStatusPermanentlyDenied; + case INSiriAuthorizationStatusNotDetermined: + return PHWStatusDenied; + } + return PHWStatusDenied; +} + +@implementation PHWAssistantStrategy + +- (Class)preferencesClass { + return phw_class(@"Intents", @"INPreferences"); +} + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + Class preferences = _optedIn() ? [self preferencesClass] : nil; + done(preferences == nil + ? PHWStatusDenied + : _assistantStatus(phw_class_integer(preferences, @selector(siriAuthorizationStatus)))); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + done(PHWServiceNotApplicable); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + if (!_optedIn()) { + done(PHWStatusDenied); + return; + } + if (!phw_has_key(@"NSSiriUsageDescription")) { + phw_missing_key(@"NSSiriUsageDescription", failed); + return; + } + Class preferences = [self preferencesClass]; + if (preferences == nil) { + done(PHWStatusPermanentlyDenied); + return; + } + PHWStatus status = + _assistantStatus(phw_class_integer(preferences, @selector(siriAuthorizationStatus))); + if (status != PHWStatusDenied) { + done(status); + return; + } + ((void (*)(Class, SEL, void (^)(INSiriAuthorizationStatus)))objc_msgSend)( + preferences, @selector(requestSiriAuthorization:), ^(INSiriAuthorizationStatus answer) { + done(_assistantStatus(answer)); + }); +} + +@end diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_bluetooth.m b/packages/permission_handler_watchos/watchos/Classes/phw_bluetooth.m new file mode 100644 index 0000000..8977cb4 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_bluetooth.m @@ -0,0 +1,124 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Bluetooth, through a CBCentralManager the strategy keeps: creating it is +// what asks the wearer, and its first state update is the answer, as in the +// iOS implementation. CoreBluetooth is loaded at runtime and only messaged. + +#import "phw_internal.h" + +#import + +static PHWStatus _bluetoothStatus(NSInteger authorization) { + switch (authorization) { + case CBManagerAuthorizationNotDetermined: + return PHWStatusDenied; + case CBManagerAuthorizationRestricted: + return PHWStatusRestricted; + case CBManagerAuthorizationDenied: + return PHWStatusPermanentlyDenied; + case CBManagerAuthorizationAllowedAlways: + return PHWStatusGranted; + } + return PHWStatusDenied; +} + +@interface PHWBluetoothStrategy () +@end + +@implementation PHWBluetoothStrategy { + CBCentralManager* _manager; + NSMutableArray* _requests; + NSMutableArray* _services; +} + +- (Class)managerClass { + return phw_class(@"CoreBluetooth", @"CBCentralManager"); +} + +- (PHWStatus)statusOf:(Class)managerClass { + return _bluetoothStatus(phw_class_integer(managerClass, @selector(authorization))); +} + +- (void)startManager:(Class)managerClass { + if (_manager != nil) { + return; + } + _requests = [NSMutableArray array]; + _services = [NSMutableArray array]; + // The option's key by its value: its constant would link CoreBluetooth. + _manager = [[managerClass alloc] initWithDelegate:self + queue:dispatch_get_main_queue() + options:@{@"kCBInitOptionShowPowerAlert" : @NO}]; +} + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + Class managerClass = [self managerClass]; + done(managerClass == nil ? PHWStatusDenied : [self statusOf:managerClass]); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + Class managerClass = [self managerClass]; + if (managerClass == nil) { + done(PHWServiceDisabled); + return; + } + if (!phw_has_key(@"NSBluetoothAlwaysUsageDescription")) { + phw_missing_key(@"NSBluetoothAlwaysUsageDescription", failed); + return; + } + if (_manager != nil && _manager.state != CBManagerStateUnknown) { + done(_manager.state == CBManagerStatePoweredOn ? PHWServiceEnabled + : PHWServiceDisabled); + return; + } + [self startManager:managerClass]; + [_services addObject:done]; +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + Class managerClass = [self managerClass]; + if (managerClass == nil) { + done(PHWStatusPermanentlyDenied); + return; + } + PHWStatus status = [self statusOf:managerClass]; + if (status != PHWStatusDenied) { + done(status); + return; + } + if (!phw_has_key(@"NSBluetoothAlwaysUsageDescription")) { + phw_missing_key(@"NSBluetoothAlwaysUsageDescription", failed); + return; + } + if (_manager != nil && _manager.state != CBManagerStateUnknown) { + // A manager already running has asked before: nothing will update. + done(status); + return; + } + [self startManager:managerClass]; + [_requests addObject:done]; +} + +- (void)centralManagerDidUpdateState:(CBCentralManager*)central { + PHWStatus status = [self statusOf:[self managerClass]]; + NSArray* requests = [_requests copy]; + [_requests removeAllObjects]; + for (PHWStatusHandler done in requests) { + done(status); + } + PHWService service = + central.state == CBManagerStatePoweredOn ? PHWServiceEnabled : PHWServiceDisabled; + NSArray* services = [_services copy]; + [_services removeAllObjects]; + for (PHWServiceHandler done in services) { + done(service); + } +} + +@end diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_contacts.m b/packages/permission_handler_watchos/watchos/Classes/phw_contacts.m new file mode 100644 index 0000000..71ebd6f --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_contacts.m @@ -0,0 +1,81 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Contacts, through CNContactStore. Contacts is loaded at runtime and only +// messaged. + +#import "phw_internal.h" + +#import + +static PHWStatus _contactsStatus(NSInteger status) { + switch (status) { + case CNAuthorizationStatusNotDetermined: + return PHWStatusDenied; + case CNAuthorizationStatusRestricted: + return PHWStatusRestricted; + case CNAuthorizationStatusDenied: + return PHWStatusPermanentlyDenied; + case CNAuthorizationStatusAuthorized: + return PHWStatusGranted; + default: + // The watchOS SDK has no CNAuthorizationStatusLimited (iOS 18 + // only); any status it adds later is not a grant. + return PHWStatusDenied; + } +} + +@implementation PHWContactsStrategy { + // Kept until its request answers. + CNContactStore* _store; +} + +- (Class)storeClass { + return phw_class(@"Contacts", @"CNContactStore"); +} + +- (PHWStatus)statusOf:(Class)storeClass { + return _contactsStatus(phw_class_integer_with( + storeClass, @selector(authorizationStatusForEntityType:), CNEntityTypeContacts)); +} + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + Class storeClass = [self storeClass]; + done(storeClass == nil ? PHWStatusDenied : [self statusOf:storeClass]); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + done(PHWServiceNotApplicable); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + Class storeClass = [self storeClass]; + if (storeClass == nil) { + done(PHWStatusPermanentlyDenied); + return; + } + PHWStatus status = [self statusOf:storeClass]; + if (status != PHWStatusDenied) { + done(status); + return; + } + if (!phw_has_key(@"NSContactsUsageDescription")) { + phw_missing_key(@"NSContactsUsageDescription", failed); + return; + } + _store = [[storeClass alloc] init]; + [_store requestAccessForEntityType:CNEntityTypeContacts + completionHandler:^(BOOL granted, NSError* error) { + dispatch_async(dispatch_get_main_queue(), ^{ + self->_store = nil; + done(granted ? [self statusOf:storeClass] : PHWStatusPermanentlyDenied); + }); + }]; +} + +@end diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_events.m b/packages/permission_handler_watchos/watchos/Classes/phw_events.m new file mode 100644 index 0000000..e397c59 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_events.m @@ -0,0 +1,113 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Calendar (full access and write only) and reminders, through +// EKEventStore, answered as the iOS 17 implementation answers them. EventKit +// is loaded at runtime and only messaged. + +#import "phw_internal.h" + +#import + +static EKEntityType _entityType(PHWPermission permission) { + return permission == PHWPermissionReminders ? EKEntityTypeReminder : EKEntityTypeEvent; +} + +static PHWStatus _eventsStatus(PHWPermission permission, NSInteger status) { + switch (status) { + case EKAuthorizationStatusNotDetermined: + return PHWStatusDenied; + case EKAuthorizationStatusRestricted: + return PHWStatusRestricted; + case EKAuthorizationStatusDenied: + return PHWStatusPermanentlyDenied; + case 3: + // EKAuthorizationStatusFullAccess, which was "authorized". + return PHWStatusGranted; + case 4: + // EKAuthorizationStatusWriteOnly. + return permission == PHWPermissionCalendarWriteOnly ? PHWStatusGranted + : PHWStatusDenied; + } + return PHWStatusDenied; +} + +// The usage description the prompt for `permission` needs. +static NSString* _usageKey(PHWPermission permission) { + switch (permission) { + case PHWPermissionReminders: + return @"NSRemindersFullAccessUsageDescription"; + case PHWPermissionCalendarWriteOnly: + return @"NSCalendarsWriteOnlyAccessUsageDescription"; + default: + return @"NSCalendarsFullAccessUsageDescription"; + } +} + +@implementation PHWEventsStrategy { + // Kept until its request answers. + EKEventStore* _store; +} + +- (Class)storeClass { + return phw_class(@"EventKit", @"EKEventStore"); +} + +- (PHWStatus)statusOf:(Class)storeClass permission:(PHWPermission)permission { + return _eventsStatus(permission, + phw_class_integer_with(storeClass, + @selector(authorizationStatusForEntityType:), + _entityType(permission))); +} + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + Class storeClass = [self storeClass]; + done(storeClass == nil ? PHWStatusDenied : [self statusOf:storeClass permission:permission]); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + done(PHWServiceNotApplicable); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + Class storeClass = [self storeClass]; + if (storeClass == nil) { + done(PHWStatusPermanentlyDenied); + return; + } + PHWStatus status = [self statusOf:storeClass permission:permission]; + if (status != PHWStatusDenied) { + done(status); + return; + } + NSString* key = _usageKey(permission); + if (!phw_has_key(key)) { + phw_missing_key(key, failed); + return; + } + _store = [[storeClass alloc] init]; + void (^answer)(BOOL, NSError*) = ^(BOOL granted, NSError* error) { + dispatch_async(dispatch_get_main_queue(), ^{ + self->_store = nil; + done(granted ? PHWStatusGranted : PHWStatusPermanentlyDenied); + }); + }; + switch (permission) { + case PHWPermissionReminders: + [_store requestFullAccessToRemindersWithCompletion:answer]; + break; + case PHWPermissionCalendarWriteOnly: + [_store requestWriteOnlyAccessToEventsWithCompletion:answer]; + break; + default: + [_store requestFullAccessToEventsWithCompletion:answer]; + break; + } +} + +@end diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_internal.h b/packages/permission_handler_watchos/watchos/Classes/phw_internal.h new file mode 100644 index 0000000..12379b4 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_internal.h @@ -0,0 +1,126 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// What the strategy files share. Nothing here is exported to Dart. + +#ifndef PHW_INTERNAL_H +#define PHW_INTERNAL_H + +#import + +// Shared between this package's files only, never with the rest of the app. +#define PHW_HIDDEN __attribute__((visibility("hidden"))) + +// permission_handler's numbers for the permissions watchOS has. +typedef NS_ENUM(int, PHWPermission) { + PHWPermissionCalendar = 0, + PHWPermissionContacts = 2, + PHWPermissionLocation = 3, + PHWPermissionLocationAlways = 4, + PHWPermissionLocationWhenInUse = 5, + PHWPermissionMicrophone = 7, + PHWPermissionReminders = 11, + PHWPermissionSensors = 12, + PHWPermissionStorage = 15, + PHWPermissionNotification = 17, + PHWPermissionBluetooth = 21, + PHWPermissionCriticalAlerts = 26, + PHWPermissionCalendarWriteOnly = 36, + PHWPermissionCalendarFullAccess = 37, + PHWPermissionAssistant = 38, +}; + +// PermissionStatus. +typedef NS_ENUM(int, PHWStatus) { + PHWStatusDenied = 0, + PHWStatusGranted = 1, + PHWStatusRestricted = 2, + PHWStatusLimited = 3, + PHWStatusPermanentlyDenied = 4, + PHWStatusProvisional = 5, +}; + +// ServiceStatus. +typedef NS_ENUM(int, PHWService) { + PHWServiceDisabled = 0, + PHWServiceEnabled = 1, + PHWServiceNotApplicable = 2, +}; + +typedef void (^PHWStatusHandler)(PHWStatus status); +typedef void (^PHWServiceHandler)(PHWService service); +typedef void (^PHWErrorHandler)(NSString* code, NSString* message); + +// One group of permissions. Its methods are called on the main queue, and +// each calls one of its handlers once, from any queue. +@protocol PHWStrategy +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done; +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed; +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed; +@end + +// The class `className` of the system framework `framework`, loaded on first +// use, or nil when this watchOS has neither. No framework but +// UserNotifications is linked, so an app does not load the frameworks of the +// permissions it never asks about. The class names and selectors are still +// in the binary: unlike the iOS implementation's opt-in macros, this does +// not take a group's code out of the app. +PHW_HIDDEN Class phw_class(NSString* framework, NSString* className); + +// Whether the app's Info.plist has `key`. +PHW_HIDDEN BOOL phw_has_key(NSString* key); + +// Fails with MISSING_USAGE_DESCRIPTION, naming `key`. +PHW_HIDDEN void phw_missing_key(NSString* key, PHWErrorHandler failed); + +// Sends a class method with no argument that returns an integer. +PHW_HIDDEN NSInteger phw_class_integer(Class cls, SEL selector); + +// Sends a class method with one integer argument that returns an integer. +PHW_HIDDEN NSInteger phw_class_integer_with(Class cls, SEL selector, NSInteger argument); + +// Sends a class method with no argument that returns a BOOL. +PHW_HIDDEN BOOL phw_class_bool(Class cls, SEL selector); + +// What answers for the permissions watchOS does not have: as the iOS +// implementation answers for an unknown permission. +@interface PHWUnknownStrategy : NSObject +@end + +@interface PHWNotificationStrategy : NSObject +@end + +@interface PHWLocationStrategy : NSObject +@end + +@interface PHWMotionStrategy : NSObject +@end + +@interface PHWMicrophoneStrategy : NSObject +@end + +@interface PHWContactsStrategy : NSObject +@end + +@interface PHWEventsStrategy : NSObject +@end + +@interface PHWBluetoothStrategy : NSObject +@end + +// Storage, granted as on iOS: the app's own container needs no permission. +@interface PHWStorageStrategy : NSObject +@end + +@interface PHWCriticalAlertsStrategy : NSObject +@end + +@interface PHWAssistantStrategy : NSObject +@end + +#endif // PHW_INTERNAL_H diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_location.m b/packages/permission_handler_watchos/watchos/Classes/phw_location.m new file mode 100644 index 0000000..2050a87 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_location.m @@ -0,0 +1,230 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Location, when in use and always, through a CLLocationManager the +// strategy keeps, answered as the iOS implementation answers them. +// +// CoreLocation is loaded at runtime and only messaged: no class of it is +// referenced by symbol, so an app that never asks for location links none +// of it. + +#import "phw_internal.h" + +#import +#import + +// Set once "always" was asked for: watchOS shows that prompt once, and a +// second request must answer without waiting for a prompt that never comes. +static NSString* const kAskedAlwaysKey = @"dev.flutterwatch.permission_handler.askedAlways"; + +// How long after the app becomes active a status still "not determined" +// waits for the delegate before it counts as a prompt closed unanswered. +static const NSTimeInterval kUnansweredDelay = 1.0; + +static PHWStatus _locationStatus(PHWPermission permission, CLAuthorizationStatus status) { + switch (status) { + case kCLAuthorizationStatusNotDetermined: + return PHWStatusDenied; + case kCLAuthorizationStatusRestricted: + return PHWStatusRestricted; + case kCLAuthorizationStatusDenied: + return PHWStatusPermanentlyDenied; + case kCLAuthorizationStatusAuthorizedWhenInUse: + return permission == PHWPermissionLocationAlways ? PHWStatusPermanentlyDenied + : PHWStatusGranted; + case kCLAuthorizationStatusAuthorizedAlways: + return PHWStatusGranted; + } + return PHWStatusDenied; +} + +@interface PHWLocationStrategy () +@end + +@implementation PHWLocationStrategy { + CLLocationManager* _manager; + // Requests waiting for the wearer's answer, and what they asked for. + NSMutableArray* _waiting; + PHWPermission _asked; + id _activeObserver; + id _resignObserver; + // Whether the app resigned active since the request: the prompt taking + // the screen does that, and only a return after it is an answer. + BOOL _resigned; + // Goes up with every answer, so a re-read armed before one stands down. + NSUInteger _answers; +} + +- (CLLocationManager*)manager { + if (_manager == nil) { + Class managerClass = phw_class(@"CoreLocation", @"CLLocationManager"); + _manager = [[managerClass alloc] init]; + _manager.delegate = self; + _waiting = [NSMutableArray array]; + } + return _manager; +} + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + CLLocationManager* manager = [self manager]; + done(manager == nil ? PHWStatusDenied + : _locationStatus(permission, manager.authorizationStatus)); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + Class managerClass = phw_class(@"CoreLocation", @"CLLocationManager"); + if (managerClass == nil) { + done(PHWServiceDisabled); + return; + } + // CoreLocation warns that this blocks; it is read off the main queue. + dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{ + BOOL enabled = phw_class_bool(managerClass, @selector(locationServicesEnabled)); + done(enabled ? PHWServiceEnabled : PHWServiceDisabled); + }); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + CLLocationManager* manager = [self manager]; + if (manager == nil) { + done(PHWStatusPermanentlyDenied); + return; + } + CLAuthorizationStatus status = manager.authorizationStatus; + if (permission == PHWPermissionLocationAlways) { + [self requestAlways:status done:done failed:failed]; + return; + } + if (status != kCLAuthorizationStatusNotDetermined) { + done(_locationStatus(permission, status)); + return; + } + if (!phw_has_key(@"NSLocationWhenInUseUsageDescription")) { + phw_missing_key(@"NSLocationWhenInUseUsageDescription", failed); + return; + } + _asked = permission; + [_waiting addObject:done]; + // A prompt closed without an answer (the crown pressed) sends no + // delegate call on watchOS, not even the second "not determined" the + // iOS implementation waits for (seen on the watchOS 27.0 Simulator), so + // the app becoming active again is the answer then. + [self observeActive]; + [manager requestWhenInUseAuthorization]; +} + +- (void)requestAlways:(CLAuthorizationStatus)status + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + if (!phw_has_key(@"NSLocationAlwaysAndWhenInUseUsageDescription") && + !phw_has_key(@"NSLocationAlwaysUsageDescription")) { + phw_missing_key(@"NSLocationAlwaysAndWhenInUseUsageDescription", failed); + return; + } + if (status == kCLAuthorizationStatusNotDetermined) { + failed(@"MISSING_WHENINUSE_PERMISSION", + @"Must have \"When in use\" permission before it is allowed to request " + @"\"Always\" permission."); + return; + } + NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults]; + if (status != kCLAuthorizationStatusAuthorizedWhenInUse || + [defaults boolForKey:kAskedAlwaysKey]) { + done(_locationStatus(PHWPermissionLocationAlways, status)); + return; + } + [defaults setBool:YES forKey:kAskedAlwaysKey]; + _asked = PHWPermissionLocationAlways; + [_waiting addObject:done]; + // Keeping "while using" changes nothing, so no delegate call comes; the + // app becoming active again after the prompt is the answer then. + [self observeActive]; + [_manager requestAlwaysAuthorization]; +} + +// Answers the waiting requests when the app becomes active again after the +// prompt took the screen (it resigned active first), with what the status is +// then. An answer the wearer gave reaches the delegate too, maybe just after: +// a status still "not determined" is read again a moment later before it +// counts as a prompt closed unanswered, unless the delegate answered in +// between. +- (void)observeActive { + if (_activeObserver != nil) { + return; + } + _resigned = NO; + __weak PHWLocationStrategy* weakSelf = self; + NSNotificationCenter* center = [NSNotificationCenter defaultCenter]; + _resignObserver = [center addObserverForName:WKApplicationWillResignActiveNotification + object:nil + queue:[NSOperationQueue mainQueue] + usingBlock:^(NSNotification* note) { + PHWLocationStrategy* strongSelf = weakSelf; + if (strongSelf != nil) { + strongSelf->_resigned = YES; + } + }]; + _activeObserver = [center addObserverForName:WKApplicationDidBecomeActiveNotification + object:nil + queue:[NSOperationQueue mainQueue] + usingBlock:^(NSNotification* note) { + PHWLocationStrategy* strongSelf = weakSelf; + if (strongSelf == nil || !strongSelf->_resigned) { + return; + } + if (strongSelf->_manager.authorizationStatus != kCLAuthorizationStatusNotDetermined) { + [strongSelf answer:strongSelf->_manager.authorizationStatus]; + return; + } + NSUInteger answers = strongSelf->_answers; + dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(kUnansweredDelay * NSEC_PER_SEC)), + dispatch_get_main_queue(), ^{ + PHWLocationStrategy* later = weakSelf; + // An answer since, from the delegate, stands this re-read down: + // a request made after it is not answered by it. + if (later != nil && later->_answers == answers) { + [later answer:later->_manager.authorizationStatus]; + } + }); + }]; +} + +- (void)answer:(CLAuthorizationStatus)status { + if (_waiting.count == 0) { + return; + } + _answers++; + if (_activeObserver != nil) { + [[NSNotificationCenter defaultCenter] removeObserver:_activeObserver]; + _activeObserver = nil; + } + if (_resignObserver != nil) { + [[NSNotificationCenter defaultCenter] removeObserver:_resignObserver]; + _resignObserver = nil; + } + NSArray* waiting = [_waiting copy]; + [_waiting removeAllObjects]; + for (PHWStatusHandler done in waiting) { + done(_locationStatus(_asked, status)); + } +} + +- (void)locationManagerDidChangeAuthorization:(CLLocationManager*)manager { + CLAuthorizationStatus status = manager.authorizationStatus; + // The manager reports its status once on creation, before any answer, and + // a prompt closed unanswered is caught by observeActive; "always" still + // at "when in use" is no answer yet either. + if (status == kCLAuthorizationStatusNotDetermined || + (_asked == PHWPermissionLocationAlways && + status == kCLAuthorizationStatusAuthorizedWhenInUse)) { + return; + } + [self answer:status]; +} + +@end diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_microphone.m b/packages/permission_handler_watchos/watchos/Classes/phw_microphone.m new file mode 100644 index 0000000..2e2b526 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_microphone.m @@ -0,0 +1,72 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// The microphone, through AVAudioApplication's record permission. AVFAudio +// is loaded at runtime and only messaged. + +#import "phw_internal.h" + +#import +#import + +static PHWStatus _recordStatus(NSInteger permission) { + switch ((AVAudioApplicationRecordPermission)permission) { + case AVAudioApplicationRecordPermissionUndetermined: + return PHWStatusDenied; + case AVAudioApplicationRecordPermissionDenied: + return PHWStatusPermanentlyDenied; + case AVAudioApplicationRecordPermissionGranted: + return PHWStatusGranted; + } + return PHWStatusDenied; +} + +@implementation PHWMicrophoneStrategy + +- (Class)applicationClass { + return phw_class(@"AVFAudio", @"AVAudioApplication"); +} + +- (PHWStatus)status { + id application = ((id (*)(Class, SEL))objc_msgSend)([self applicationClass], + @selector(sharedInstance)); + return _recordStatus(((NSInteger (*)(id, SEL))objc_msgSend)(application, + @selector(recordPermission))); +} + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + done([self applicationClass] == nil ? PHWStatusDenied : [self status]); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + done(PHWServiceNotApplicable); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + Class applicationClass = [self applicationClass]; + if (applicationClass == nil) { + done(PHWStatusPermanentlyDenied); + return; + } + PHWStatus status = [self status]; + if (status != PHWStatusDenied) { + done(status); + return; + } + if (!phw_has_key(@"NSMicrophoneUsageDescription")) { + phw_missing_key(@"NSMicrophoneUsageDescription", failed); + return; + } + ((void (*)(Class, SEL, void (^)(BOOL)))objc_msgSend)( + applicationClass, @selector(requestRecordPermissionWithCompletionHandler:), + ^(BOOL granted) { + done(granted ? PHWStatusGranted : PHWStatusPermanentlyDenied); + }); +} + +@end diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_motion.m b/packages/permission_handler_watchos/watchos/Classes/phw_motion.m new file mode 100644 index 0000000..f79f40e --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_motion.m @@ -0,0 +1,82 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Sensors: Motion & Fitness access, through CMMotionActivityManager, asked +// for with a query as the iOS implementation asks. CoreMotion is loaded at +// runtime and only messaged. + +#import "phw_internal.h" + +#import + +static PHWStatus _motionStatus(NSInteger status) { + switch ((CMAuthorizationStatus)status) { + case CMAuthorizationStatusNotDetermined: + return PHWStatusDenied; + case CMAuthorizationStatusRestricted: + return PHWStatusRestricted; + case CMAuthorizationStatusDenied: + return PHWStatusPermanentlyDenied; + case CMAuthorizationStatusAuthorized: + return PHWStatusGranted; + } + return PHWStatusGranted; +} + +@implementation PHWMotionStrategy { + // Kept until its query answers. + CMMotionActivityManager* _manager; +} + +- (Class)managerClass { + return phw_class(@"CoreMotion", @"CMMotionActivityManager"); +} + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + Class managerClass = [self managerClass]; + done(managerClass == nil + ? PHWStatusDenied + : _motionStatus(phw_class_integer(managerClass, @selector(authorizationStatus)))); +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + Class managerClass = [self managerClass]; + BOOL available = + managerClass != nil && phw_class_bool(managerClass, @selector(isActivityAvailable)); + done(available ? PHWServiceEnabled : PHWServiceDisabled); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + Class managerClass = [self managerClass]; + if (managerClass == nil) { + done(PHWStatusPermanentlyDenied); + return; + } + PHWStatus status = + _motionStatus(phw_class_integer(managerClass, @selector(authorizationStatus))); + if (status != PHWStatusDenied) { + done(status); + return; + } + if (!phw_has_key(@"NSMotionUsageDescription")) { + phw_missing_key(@"NSMotionUsageDescription", failed); + return; + } + _manager = [[managerClass alloc] init]; + NSDate* now = [NSDate date]; + [_manager queryActivityStartingFromDate:now + toDate:now + toQueue:[NSOperationQueue mainQueue] + withHandler:^(NSArray* activities, + NSError* error) { + self->_manager = nil; + done(_motionStatus(phw_class_integer(managerClass, @selector(authorizationStatus)))); + }]; +} + +@end diff --git a/packages/permission_handler_watchos/watchos/Classes/phw_notification.m b/packages/permission_handler_watchos/watchos/Classes/phw_notification.m new file mode 100644 index 0000000..91e2075 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Classes/phw_notification.m @@ -0,0 +1,110 @@ +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// Notifications and critical alerts, through UNUserNotificationCenter, +// answered as the iOS implementation answers them. The only framework this +// package links: it needs no usage description. + +#import "phw_internal.h" + +#import + +static PHWStatus _notificationStatus(UNAuthorizationStatus status) { + switch (status) { + case UNAuthorizationStatusNotDetermined: + return PHWStatusDenied; + case UNAuthorizationStatusDenied: + return PHWStatusPermanentlyDenied; + case UNAuthorizationStatusProvisional: + return PHWStatusProvisional; + default: + // Authorized, and ephemeral for an App Clip. + return PHWStatusGranted; + } +} + +@implementation PHWNotificationStrategy + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + [[UNUserNotificationCenter currentNotificationCenter] + getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings* settings) { + done(_notificationStatus(settings.authorizationStatus)); + }]; +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + done(PHWServiceNotApplicable); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + UNUserNotificationCenter* center = [UNUserNotificationCenter currentNotificationCenter]; + [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings* settings) { + PHWStatus status = _notificationStatus(settings.authorizationStatus); + // Provisional can still be raised to full authorization. + if (status != PHWStatusDenied && status != PHWStatusProvisional) { + done(status); + return; + } + UNAuthorizationOptions options = UNAuthorizationOptionAlert | + UNAuthorizationOptionSound | + UNAuthorizationOptionBadge; + [center requestAuthorizationWithOptions:options + completionHandler:^(BOOL granted, NSError* error) { + done(granted && error == nil ? PHWStatusGranted : PHWStatusPermanentlyDenied); + }]; + }]; +} + +@end + +// What the iOS implementation reads from criticalAlertSetting: on, off, and +// not supported, which an app without the Critical Alerts entitlement gets. +static PHWStatus _criticalStatus(UNNotificationSettings* settings) { + switch (settings.criticalAlertSetting) { + case UNNotificationSettingEnabled: + return PHWStatusGranted; + case UNNotificationSettingDisabled: + return PHWStatusPermanentlyDenied; + default: + return PHWStatusDenied; + } +} + +@implementation PHWCriticalAlertsStrategy + +- (void)checkPermission:(PHWPermission)permission done:(PHWStatusHandler)done { + [[UNUserNotificationCenter currentNotificationCenter] + getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings* settings) { + done(_criticalStatus(settings)); + }]; +} + +- (void)checkService:(PHWPermission)permission + done:(PHWServiceHandler)done + failed:(PHWErrorHandler)failed { + done(PHWServiceNotApplicable); +} + +- (void)requestPermission:(PHWPermission)permission + done:(PHWStatusHandler)done + failed:(PHWErrorHandler)failed { + UNUserNotificationCenter* center = [UNUserNotificationCenter currentNotificationCenter]; + [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings* settings) { + PHWStatus status = _criticalStatus(settings); + if (status != PHWStatusDenied) { + done(status); + return; + } + [center requestAuthorizationWithOptions:UNAuthorizationOptionCriticalAlert + completionHandler:^(BOOL granted, NSError* error) { + done(granted && error == nil ? PHWStatusGranted : PHWStatusPermanentlyDenied); + }]; + }]; +} + +@end diff --git a/packages/permission_handler_watchos/watchos/Package.swift b/packages/permission_handler_watchos/watchos/Package.swift new file mode 100644 index 0000000..fb9aab5 --- /dev/null +++ b/packages/permission_handler_watchos/watchos/Package.swift @@ -0,0 +1,37 @@ +// swift-tools-version:5.9 +// Copyright 2026 The FlutterWatch Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be found +// in the LICENSE file. +// +// The FFI manifest: what the CLI compiles into the watch binary. +import PackageDescription + +let package = Package( + name: "permission_handler_watchos", + // The microphone and the full-access and write-only calendar prompts + // are watchOS 10 APIs, and flutter-watchos apps target watchOS 26. + platforms: [ + .watchOS("10.0"), + ], + products: [ + .library(name: "permission-handler-watchos", targets: ["permission_handler_watchos"]), + ], + targets: [ + .target( + name: "permission_handler_watchos", + path: "Classes", + publicHeadersPath: ".", + cSettings: [ + .headerSearchPath("."), + ], + linkerSettings: [ + .linkedFramework("Foundation"), + .linkedFramework("WatchKit"), + // Notifications need no usage description, so they are the + // one group linked. The other frameworks are loaded at + // runtime, only when a permission of theirs is asked for. + .linkedFramework("UserNotifications"), + ] + ), + ] +) diff --git a/tool/upstream_versions.yaml b/tool/upstream_versions.yaml index a186683..36b7b78 100644 --- a/tool/upstream_versions.yaml +++ b/tool/upstream_versions.yaml @@ -24,6 +24,7 @@ upstreams: network_info_plus: 8.2.1 package_info_plus: 10.2.1 path_provider: 2.1.6 + permission_handler: 13.0.2 sensors_plus: 7.1.0 shared_preferences: 2.5.5 sqflite: 2.4.5 diff --git a/tool/words/forbidden_words_allow.txt b/tool/words/forbidden_words_allow.txt index 6587c50..7b6aed4 100644 --- a/tool/words/forbidden_words_allow.txt +++ b/tool/words/forbidden_words_allow.txt @@ -26,6 +26,7 @@ packages/in_app_purchase_watchos/lib/in_app_purchase_watchos.dart | rawPrice: (p packages/audioplayers_watchos/**/LICENSE | Permission is hereby granted, free of charge, | The MIT licence text of an upstream plugin, which stays verbatim. packages/geolocator_watchos/LICENSE | Permission is hereby granted, free of charge, | The MIT licence text of an upstream plugin, which stays verbatim. packages/games_services_watchos/example/LICENSE | Permission is hereby granted, free of charge, | The MIT licence text of the upstream example, which stays verbatim. +packages/permission_handler_watchos/LICENSE | Permission is hereby granted, free of charge, | The MIT licence text of an upstream plugin, which stays verbatim. packages/audioplayers_watchos/**/*.dart | calloc.free( | package:ffi's calloc.free, which releases native memory; a Dart API call. packages/firebase_*_watchos/**/*.dart | calloc.free( | package:ffi's calloc.free, which releases native memory; a Dart API call. packages/flutter_watch_link/**/*.dart | calloc.free( | package:ffi's calloc.free, which releases native memory; a Dart API call. @@ -42,6 +43,7 @@ packages/flutter_watch_link/**/*.m | free( | C's free(), which releases native m packages/games_services_watchos/**/*.m | free( | C's free(), which releases native memory; also the tail of each plugin's exported *_free function. packages/in_app_purchase_watchos/**/*.m | free( | C's free(), which releases native memory; also the tail of each plugin's exported *_free function. packages/network_info_plus_watchos/**/*.m | free( | C's free(), which releases native memory; also the tail of each plugin's exported *_free function. +packages/permission_handler_watchos/**/*.m | free( | C's free(), which releases native memory; here the body of the plugin's exported *_release function. packages/shared_preferences_watchos/**/*.m | free( | C's free(), which releases native memory; also the tail of each plugin's exported *_free function. packages/firebase_*_watchos/** | _watchos_free | The C function each plugin exports to release a string it returned; a symbol name, also in ffiSymbols and in Dart lookups. packages/flutter_secure_storage_watchos/** | _watchos_free | The C function each plugin exports to release a string it returned; a symbol name, also in ffiSymbols and in Dart lookups.