diff --git a/.github/workflows/beta.yml b/.github/workflows/beta.yml index 4011056d950..788cc1415ac 100644 --- a/.github/workflows/beta.yml +++ b/.github/workflows/beta.yml @@ -26,7 +26,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: actions/setup-java@99b8673ff64fbf99d8d325f52d9a5bdedb8483e9 with: distribution: 'zulu' @@ -41,7 +41,7 @@ jobs: runs-on: ubuntu-latest if: github.repository == 'flutter/samples' steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: actions/setup-java@99b8673ff64fbf99d8d325f52d9a5bdedb8483e9 with: distribution: 'zulu' @@ -56,7 +56,7 @@ jobs: runs-on: macos-latest if: github.repository == 'flutter/samples' steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: actions/setup-java@99b8673ff64fbf99d8d325f52d9a5bdedb8483e9 with: distribution: 'zulu' diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml index 5313efd85f0..b2cb939938f 100644 --- a/.github/workflows/gh-pages.yml +++ b/.github/workflows/gh-pages.yml @@ -16,7 +16,7 @@ jobs: steps: - name: Checkout - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b with: submodules: true fetch-depth: 0 diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 9cc4da863d3..797890b0397 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -27,7 +27,7 @@ jobs: flutter_version: [stable, beta, master] os: [ubuntu-latest, macos-latest, windows-latest] steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: actions/setup-java@99b8673ff64fbf99d8d325f52d9a5bdedb8483e9 with: distribution: 'zulu' @@ -40,7 +40,7 @@ jobs: name: web/samples_index config check runs-on: ubuntu-latest steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: subosito/flutter-action@44ac965b96f18d999802d4b807e3256d5a3f9fa1 - run: | dart pub get @@ -50,7 +50,7 @@ jobs: runs-on: ubuntu-latest if: github.repository == 'flutter/samples' steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: actions/setup-java@99b8673ff64fbf99d8d325f52d9a5bdedb8483e9 with: distribution: 'zulu' @@ -63,7 +63,7 @@ jobs: runs-on: macos-latest if: github.repository == 'flutter/samples' steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: actions/setup-java@99b8673ff64fbf99d8d325f52d9a5bdedb8483e9 with: distribution: 'zulu' diff --git a/.github/workflows/scorecards-analysis.yml b/.github/workflows/scorecards-analysis.yml index 99b1a59b9c0..f02e73fc59b 100644 --- a/.github/workflows/scorecards-analysis.yml +++ b/.github/workflows/scorecards-analysis.yml @@ -22,12 +22,12 @@ jobs: steps: - name: "Checkout code" - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b with: persist-credentials: false - name: "Run analysis" - uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 + uses: ossf/scorecard-action@dc50aa9510b46c811795eb24b2f1ba02a914e534 with: results_file: results.sarif results_format: sarif diff --git a/.github/workflows/verify-web-demos.yml b/.github/workflows/verify-web-demos.yml index 1fa8be29644..c817754dd58 100644 --- a/.github/workflows/verify-web-demos.yml +++ b/.github/workflows/verify-web-demos.yml @@ -21,7 +21,7 @@ jobs: # - beta steps: - name: Checkout - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b with: submodules: true fetch-depth: 0 diff --git a/add_to_app/books/flutter_module_books/pubspec.yaml b/add_to_app/books/flutter_module_books/pubspec.yaml index 58c1ff0b215..88181a887a1 100644 --- a/add_to_app/books/flutter_module_books/pubspec.yaml +++ b/add_to_app/books/flutter_module_books/pubspec.yaml @@ -15,7 +15,7 @@ dependencies: dev_dependencies: analysis_defaults: path: ../../../analysis_defaults - pigeon: ">=11.0.0 <18.0.0" + pigeon: ">=11.0.0 <19.0.0" flutter_test: sdk: flutter diff --git a/analysis_defaults/pubspec.yaml b/analysis_defaults/pubspec.yaml index 7b3f46ca46b..4cc71eb214f 100644 --- a/analysis_defaults/pubspec.yaml +++ b/analysis_defaults/pubspec.yaml @@ -8,4 +8,4 @@ environment: # NOTE: Code is not allowed in this package. Do not add more dependencies. # The `flutter_lints` dependency is required for `lib/flutter.yaml`. dependencies: - flutter_lints: ^3.0.0 + flutter_lints: ^4.0.0 diff --git a/code_sharing/client/pubspec.yaml b/code_sharing/client/pubspec.yaml index 1a07f4cff0e..7c2f58fc613 100644 --- a/code_sharing/client/pubspec.yaml +++ b/code_sharing/client/pubspec.yaml @@ -15,7 +15,7 @@ dependencies: path: ../shared dev_dependencies: - flutter_lints: ^3.0.0 + flutter_lints: ^4.0.0 flutter_test: sdk: flutter diff --git a/code_sharing/server/pubspec.yaml b/code_sharing/server/pubspec.yaml index 51ccf688ccd..dde88039de4 100644 --- a/code_sharing/server/pubspec.yaml +++ b/code_sharing/server/pubspec.yaml @@ -15,5 +15,5 @@ dependencies: dev_dependencies: http: ^1.0.0 - lints: ^3.0.0 + lints: ^4.0.0 test: ^1.15.0 diff --git a/code_sharing/shared/pubspec.yaml b/code_sharing/shared/pubspec.yaml index 94a4c4157cf..0bccdaf0e2f 100644 --- a/code_sharing/shared/pubspec.yaml +++ b/code_sharing/shared/pubspec.yaml @@ -13,5 +13,5 @@ dev_dependencies: build_runner: ^2.2.1 freezed: ^2.1.1 json_serializable: ^6.4.0 - lints: ">=2.0.0 <4.0.0" + lints: ">=2.0.0 <5.0.0" test: ^1.16.0 diff --git a/deeplink_store_example/pubspec.yaml b/deeplink_store_example/pubspec.yaml index 3032febc972..a8c1525af04 100644 --- a/deeplink_store_example/pubspec.yaml +++ b/deeplink_store_example/pubspec.yaml @@ -47,7 +47,7 @@ dev_dependencies: # activated in the `analysis_options.yaml` file located at the root of your # package. See that file for information about deactivating specific lint # rules and activating additional ones. - flutter_lints: ^3.0.0 + flutter_lints: ^4.0.0 # For information on the generic Dart part of this file, see the # following page: https://dart.dev/tools/pub/pubspec diff --git a/dynamic_theme/.gitignore b/dynamic_theme/.gitignore new file mode 100644 index 00000000000..29a3a5017f0 --- /dev/null +++ b/dynamic_theme/.gitignore @@ -0,0 +1,43 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.buildlog/ +.history +.svn/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# The .vscode folder contains launch configuration and tasks you configure in +# VS Code which you may wish to be included in version control, so this line +# is commented out by default. +#.vscode/ + +# Flutter/Dart/Pub related +**/doc/api/ +**/ios/Flutter/.last_build_id +.dart_tool/ +.flutter-plugins +.flutter-plugins-dependencies +.pub-cache/ +.pub/ +/build/ + +# Symbolication related +app.*.symbols + +# Obfuscation related +app.*.map.json + +# Android Studio will place build artifacts here +/android/app/debug +/android/app/profile +/android/app/release diff --git a/dynamic_theme/.metadata b/dynamic_theme/.metadata new file mode 100644 index 00000000000..8629a4e1864 --- /dev/null +++ b/dynamic_theme/.metadata @@ -0,0 +1,45 @@ +# This file tracks properties of this Flutter project. +# Used by Flutter tool to assess capabilities and perform upgrades etc. +# +# This file should be version controlled and should not be manually edited. + +version: + revision: "abb292a07e20d696c4568099f918f6c5f330e6b0" + channel: "stable" + +project_type: app + +# Tracks metadata for the flutter migrate command +migration: + platforms: + - platform: root + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: android + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: ios + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: linux + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: macos + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: web + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: windows + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + + # User provided section + + # List of Local paths (relative to this file) that should be + # ignored by the migrate tool. + # + # Files that are not part of the templates will be ignored by default. + unmanaged_files: + - 'lib/main.dart' + - 'ios/Runner.xcodeproj/project.pbxproj' diff --git a/dynamic_theme/analysis_options.yaml b/dynamic_theme/analysis_options.yaml new file mode 100644 index 00000000000..0d2902135ca --- /dev/null +++ b/dynamic_theme/analysis_options.yaml @@ -0,0 +1,28 @@ +# This file configures the analyzer, which statically analyzes Dart code to +# check for errors, warnings, and lints. +# +# The issues identified by the analyzer are surfaced in the UI of Dart-enabled +# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be +# invoked from the command line by running `flutter analyze`. + +# The following line activates a set of recommended lints for Flutter apps, +# packages, and plugins designed to encourage good coding practices. +include: package:flutter_lints/flutter.yaml + +linter: + # The lint rules applied to this project can be customized in the + # section below to disable rules from the `package:flutter_lints/flutter.yaml` + # included above or to enable additional rules. A list of all available lints + # and their documentation is published at https://dart.dev/lints. + # + # Instead of disabling a lint rule for the entire project in the + # section below, it can also be suppressed for a single line of code + # or a specific dart file by using the `// ignore: name_of_lint` and + # `// ignore_for_file: name_of_lint` syntax on the line or in the file + # producing the lint. + rules: + # avoid_print: false # Uncomment to disable the `avoid_print` rule + # prefer_single_quotes: true # Uncomment to enable the `prefer_single_quotes` rule + +# Additional information about this file can be found at +# https://dart.dev/guides/language/analysis-options diff --git a/dynamic_theme/android/.gitignore b/dynamic_theme/android/.gitignore new file mode 100644 index 00000000000..6f568019d3c --- /dev/null +++ b/dynamic_theme/android/.gitignore @@ -0,0 +1,13 @@ +gradle-wrapper.jar +/.gradle +/captures/ +/gradlew +/gradlew.bat +/local.properties +GeneratedPluginRegistrant.java + +# Remember to never publicly share your keystore. +# See https://flutter.dev/docs/deployment/android#reference-the-keystore-from-the-app +key.properties +**/*.keystore +**/*.jks diff --git a/dynamic_theme/android/app/build.gradle b/dynamic_theme/android/app/build.gradle new file mode 100644 index 00000000000..9ef1adade8f --- /dev/null +++ b/dynamic_theme/android/app/build.gradle @@ -0,0 +1,67 @@ +plugins { + id "com.android.application" + id "kotlin-android" + id "dev.flutter.flutter-gradle-plugin" +} + +def localProperties = new Properties() +def localPropertiesFile = rootProject.file('local.properties') +if (localPropertiesFile.exists()) { + localPropertiesFile.withReader('UTF-8') { reader -> + localProperties.load(reader) + } +} + +def flutterVersionCode = localProperties.getProperty('flutter.versionCode') +if (flutterVersionCode == null) { + flutterVersionCode = '1' +} + +def flutterVersionName = localProperties.getProperty('flutter.versionName') +if (flutterVersionName == null) { + flutterVersionName = '1.0' +} + +android { + namespace "com.example.dynamic_theme" + compileSdk flutter.compileSdkVersion + ndkVersion flutter.ndkVersion + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + kotlinOptions { + jvmTarget = '1.8' + } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } + + defaultConfig { + // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html). + applicationId "com.example.dynamic_theme" + // You can update the following values to match your application needs. + // For more information, see: https://docs.flutter.dev/deployment/android#reviewing-the-gradle-build-configuration. + minSdkVersion flutter.minSdkVersion + targetSdkVersion flutter.targetSdkVersion + versionCode flutterVersionCode.toInteger() + versionName flutterVersionName + } + + buildTypes { + release { + // TODO: Add your own signing config for the release build. + // Signing with the debug keys for now, so `flutter run --release` works. + signingConfig signingConfigs.debug + } + } +} + +flutter { + source '../..' +} + +dependencies {} diff --git a/dynamic_theme/android/app/src/debug/AndroidManifest.xml b/dynamic_theme/android/app/src/debug/AndroidManifest.xml new file mode 100644 index 00000000000..399f6981d5d --- /dev/null +++ b/dynamic_theme/android/app/src/debug/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/dynamic_theme/android/app/src/main/AndroidManifest.xml b/dynamic_theme/android/app/src/main/AndroidManifest.xml new file mode 100644 index 00000000000..b8df4d66487 --- /dev/null +++ b/dynamic_theme/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/dynamic_theme/android/app/src/main/kotlin/com/example/dynamic_theme/MainActivity.kt b/dynamic_theme/android/app/src/main/kotlin/com/example/dynamic_theme/MainActivity.kt new file mode 100644 index 00000000000..5940b5f49d0 --- /dev/null +++ b/dynamic_theme/android/app/src/main/kotlin/com/example/dynamic_theme/MainActivity.kt @@ -0,0 +1,5 @@ +package com.example.dynamic_theme + +import io.flutter.embedding.android.FlutterActivity + +class MainActivity: FlutterActivity() diff --git a/dynamic_theme/android/app/src/main/res/drawable-v21/launch_background.xml b/dynamic_theme/android/app/src/main/res/drawable-v21/launch_background.xml new file mode 100644 index 00000000000..f74085f3f6a --- /dev/null +++ b/dynamic_theme/android/app/src/main/res/drawable-v21/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/dynamic_theme/android/app/src/main/res/drawable/launch_background.xml b/dynamic_theme/android/app/src/main/res/drawable/launch_background.xml new file mode 100644 index 00000000000..304732f8842 --- /dev/null +++ b/dynamic_theme/android/app/src/main/res/drawable/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/dynamic_theme/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/dynamic_theme/android/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 00000000000..db77bb4b7b0 Binary files /dev/null and b/dynamic_theme/android/app/src/main/res/mipmap-hdpi/ic_launcher.png differ diff --git a/dynamic_theme/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/dynamic_theme/android/app/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 00000000000..17987b79bb8 Binary files /dev/null and b/dynamic_theme/android/app/src/main/res/mipmap-mdpi/ic_launcher.png differ diff --git a/dynamic_theme/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/dynamic_theme/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png new file mode 100644 index 00000000000..09d4391482b Binary files /dev/null and b/dynamic_theme/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ diff --git a/dynamic_theme/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/dynamic_theme/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 00000000000..d5f1c8d34e7 Binary files /dev/null and b/dynamic_theme/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ diff --git a/dynamic_theme/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/dynamic_theme/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 00000000000..4d6372eebdb Binary files /dev/null and b/dynamic_theme/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ diff --git a/dynamic_theme/android/app/src/main/res/values-night/styles.xml b/dynamic_theme/android/app/src/main/res/values-night/styles.xml new file mode 100644 index 00000000000..06952be745f --- /dev/null +++ b/dynamic_theme/android/app/src/main/res/values-night/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/dynamic_theme/android/app/src/main/res/values/styles.xml b/dynamic_theme/android/app/src/main/res/values/styles.xml new file mode 100644 index 00000000000..cb1ef88056e --- /dev/null +++ b/dynamic_theme/android/app/src/main/res/values/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/dynamic_theme/android/app/src/profile/AndroidManifest.xml b/dynamic_theme/android/app/src/profile/AndroidManifest.xml new file mode 100644 index 00000000000..399f6981d5d --- /dev/null +++ b/dynamic_theme/android/app/src/profile/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/dynamic_theme/android/build.gradle b/dynamic_theme/android/build.gradle new file mode 100644 index 00000000000..bc157bd1a12 --- /dev/null +++ b/dynamic_theme/android/build.gradle @@ -0,0 +1,18 @@ +allprojects { + repositories { + google() + mavenCentral() + } +} + +rootProject.buildDir = '../build' +subprojects { + project.buildDir = "${rootProject.buildDir}/${project.name}" +} +subprojects { + project.evaluationDependsOn(':app') +} + +tasks.register("clean", Delete) { + delete rootProject.buildDir +} diff --git a/dynamic_theme/android/gradle.properties b/dynamic_theme/android/gradle.properties new file mode 100644 index 00000000000..598d13fee44 --- /dev/null +++ b/dynamic_theme/android/gradle.properties @@ -0,0 +1,3 @@ +org.gradle.jvmargs=-Xmx4G +android.useAndroidX=true +android.enableJetifier=true diff --git a/dynamic_theme/android/gradle/wrapper/gradle-wrapper.properties b/dynamic_theme/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000000..e1ca574ef01 --- /dev/null +++ b/dynamic_theme/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.3-all.zip diff --git a/dynamic_theme/android/settings.gradle b/dynamic_theme/android/settings.gradle new file mode 100644 index 00000000000..1d6d19b7f8e --- /dev/null +++ b/dynamic_theme/android/settings.gradle @@ -0,0 +1,26 @@ +pluginManagement { + def flutterSdkPath = { + def properties = new Properties() + file("local.properties").withInputStream { properties.load(it) } + def flutterSdkPath = properties.getProperty("flutter.sdk") + assert flutterSdkPath != null, "flutter.sdk not set in local.properties" + return flutterSdkPath + } + settings.ext.flutterSdkPath = flutterSdkPath() + + includeBuild("${settings.ext.flutterSdkPath}/packages/flutter_tools/gradle") + + repositories { + google() + mavenCentral() + gradlePluginPortal() + } +} + +plugins { + id "dev.flutter.flutter-plugin-loader" version "1.0.0" + id "com.android.application" version "7.3.0" apply false + id "org.jetbrains.kotlin.android" version "1.7.10" apply false +} + +include ":app" diff --git a/dynamic_theme/ios/.gitignore b/dynamic_theme/ios/.gitignore new file mode 100644 index 00000000000..7a7f9873ad7 --- /dev/null +++ b/dynamic_theme/ios/.gitignore @@ -0,0 +1,34 @@ +**/dgph +*.mode1v3 +*.mode2v3 +*.moved-aside +*.pbxuser +*.perspectivev3 +**/*sync/ +.sconsign.dblite +.tags* +**/.vagrant/ +**/DerivedData/ +Icon? +**/Pods/ +**/.symlinks/ +profile +xcuserdata +**/.generated/ +Flutter/App.framework +Flutter/Flutter.framework +Flutter/Flutter.podspec +Flutter/Generated.xcconfig +Flutter/ephemeral/ +Flutter/app.flx +Flutter/app.zip +Flutter/flutter_assets/ +Flutter/flutter_export_environment.sh +ServiceDefinitions.json +Runner/GeneratedPluginRegistrant.* + +# Exceptions to above rules. +!default.mode1v3 +!default.mode2v3 +!default.pbxuser +!default.perspectivev3 diff --git a/dynamic_theme/ios/Flutter/AppFrameworkInfo.plist b/dynamic_theme/ios/Flutter/AppFrameworkInfo.plist new file mode 100644 index 00000000000..7c569640062 --- /dev/null +++ b/dynamic_theme/ios/Flutter/AppFrameworkInfo.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + App + CFBundleIdentifier + io.flutter.flutter.app + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + App + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1.0 + MinimumOSVersion + 12.0 + + diff --git a/dynamic_theme/ios/Flutter/Debug.xcconfig b/dynamic_theme/ios/Flutter/Debug.xcconfig new file mode 100644 index 00000000000..ec97fc6f302 --- /dev/null +++ b/dynamic_theme/ios/Flutter/Debug.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig" +#include "Generated.xcconfig" diff --git a/dynamic_theme/ios/Flutter/Release.xcconfig b/dynamic_theme/ios/Flutter/Release.xcconfig new file mode 100644 index 00000000000..c4855bfe200 --- /dev/null +++ b/dynamic_theme/ios/Flutter/Release.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig" +#include "Generated.xcconfig" diff --git a/dynamic_theme/ios/Podfile b/dynamic_theme/ios/Podfile new file mode 100644 index 00000000000..d97f17e223f --- /dev/null +++ b/dynamic_theme/ios/Podfile @@ -0,0 +1,44 @@ +# Uncomment this line to define a global platform for your project +# platform :ios, '12.0' + +# CocoaPods analytics sends network stats synchronously affecting flutter build latency. +ENV['COCOAPODS_DISABLE_STATS'] = 'true' + +project 'Runner', { + 'Debug' => :debug, + 'Profile' => :release, + 'Release' => :release, +} + +def flutter_root + generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'Generated.xcconfig'), __FILE__) + unless File.exist?(generated_xcode_build_settings_path) + raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure flutter pub get is executed first" + end + + File.foreach(generated_xcode_build_settings_path) do |line| + matches = line.match(/FLUTTER_ROOT\=(.*)/) + return matches[1].strip if matches + end + raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Generated.xcconfig, then run flutter pub get" +end + +require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root) + +flutter_ios_podfile_setup + +target 'Runner' do + use_frameworks! + use_modular_headers! + + flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__)) + target 'RunnerTests' do + inherit! :search_paths + end +end + +post_install do |installer| + installer.pods_project.targets.each do |target| + flutter_additional_ios_build_settings(target) + end +end diff --git a/dynamic_theme/ios/Runner.xcodeproj/project.pbxproj b/dynamic_theme/ios/Runner.xcodeproj/project.pbxproj new file mode 100644 index 00000000000..c044b87cbd7 --- /dev/null +++ b/dynamic_theme/ios/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,616 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXBuildFile section */ + 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; }; + 331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; }; + 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; }; + 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; }; + 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; }; + 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; }; + 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C8085294A63A400263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 97C146E61CF9000F007C117D /* Project object */; + proxyType = 1; + remoteGlobalIDString = 97C146ED1CF9000F007C117D; + remoteInfo = Runner; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 9705A1C41CF9048500538489 /* Embed Frameworks */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Embed Frameworks"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = ""; }; + 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = ""; }; + 331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = ""; }; + 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = ""; }; + 74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = ""; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = ""; }; + 9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = ""; }; + 97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; + 97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + 97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; + 97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 97C146EB1CF9000F007C117D /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 331C8082294A63A400263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C807B294A618700263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 9740EEB11CF90186004384FC /* Flutter */ = { + isa = PBXGroup; + children = ( + 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 9740EEB31CF90195004384FC /* Generated.xcconfig */, + ); + name = Flutter; + sourceTree = ""; + }; + 97C146E51CF9000F007C117D = { + isa = PBXGroup; + children = ( + 9740EEB11CF90186004384FC /* Flutter */, + 97C146F01CF9000F007C117D /* Runner */, + 97C146EF1CF9000F007C117D /* Products */, + 331C8082294A63A400263BE5 /* RunnerTests */, + ); + sourceTree = ""; + }; + 97C146EF1CF9000F007C117D /* Products */ = { + isa = PBXGroup; + children = ( + 97C146EE1CF9000F007C117D /* Runner.app */, + 331C8081294A63A400263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 97C146F01CF9000F007C117D /* Runner */ = { + isa = PBXGroup; + children = ( + 97C146FA1CF9000F007C117D /* Main.storyboard */, + 97C146FD1CF9000F007C117D /* Assets.xcassets */, + 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */, + 97C147021CF9000F007C117D /* Info.plist */, + 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */, + 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */, + 74858FAE1ED2DC5600515810 /* AppDelegate.swift */, + 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */, + ); + path = Runner; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C8080294A63A400263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 331C807D294A63A400263BE5 /* Sources */, + 331C807F294A63A400263BE5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 331C8086294A63A400263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C8081294A63A400263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 97C146ED1CF9000F007C117D /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + 9740EEB61CF901F6004384FC /* Run Script */, + 97C146EA1CF9000F007C117D /* Sources */, + 97C146EB1CF9000F007C117D /* Frameworks */, + 97C146EC1CF9000F007C117D /* Resources */, + 9705A1C41CF9048500538489 /* Embed Frameworks */, + 3B06AD1E1E4923F5004D2608 /* Thin Binary */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = Runner; + productName = Runner; + productReference = 97C146EE1CF9000F007C117D /* Runner.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 97C146E61CF9000F007C117D /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C8080294A63A400263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 97C146ED1CF9000F007C117D; + }; + 97C146ED1CF9000F007C117D = { + CreatedOnToolsVersion = 7.3.1; + LastSwiftMigration = 1100; + }; + }; + }; + buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 97C146E51CF9000F007C117D; + productRefGroup = 97C146EF1CF9000F007C117D /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 97C146ED1CF9000F007C117D /* Runner */, + 331C8080294A63A400263BE5 /* RunnerTests */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C807F294A63A400263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EC1CF9000F007C117D /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */, + 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */, + 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */, + 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 3B06AD1E1E4923F5004D2608 /* Thin Binary */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + "${TARGET_BUILD_DIR}/${INFOPLIST_PATH}", + ); + name = "Thin Binary"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin"; + }; + 9740EEB61CF901F6004384FC /* Run Script */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "Run Script"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build"; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C807D294A63A400263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EA1CF9000F007C117D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */, + 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C8086294A63A400263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 97C146ED1CF9000F007C117D /* Runner */; + targetProxy = 331C8085294A63A400263BE5 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 97C146FA1CF9000F007C117D /* Main.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 97C146FB1CF9000F007C117D /* Base */, + ); + name = Main.storyboard; + sourceTree = ""; + }; + 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 97C147001CF9000F007C117D /* Base */, + ); + name = LaunchScreen.storyboard; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 249021D3217E4FDB00AE95B9 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SUPPORTED_PLATFORMS = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Profile; + }; + 249021D4217E4FDB00AE95B9 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Profile; + }; + 331C8088294A63A400263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Debug; + }; + 331C8089294A63A400263BE5 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Release; + }; + 331C808A294A63A400263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Profile; + }; + 97C147031CF9000F007C117D /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 97C147041CF9000F007C117D /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SUPPORTED_PLATFORMS = iphoneos; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 97C147061CF9000F007C117D /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Debug; + }; + 97C147071CF9000F007C117D /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C8088294A63A400263BE5 /* Debug */, + 331C8089294A63A400263BE5 /* Release */, + 331C808A294A63A400263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 97C147031CF9000F007C117D /* Debug */, + 97C147041CF9000F007C117D /* Release */, + 249021D3217E4FDB00AE95B9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 97C147061CF9000F007C117D /* Debug */, + 97C147071CF9000F007C117D /* Release */, + 249021D4217E4FDB00AE95B9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 97C146E61CF9000F007C117D /* Project object */; +} diff --git a/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 00000000000..919434a6254 --- /dev/null +++ b/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings b/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings new file mode 100644 index 00000000000..f9b0d7c5ea1 --- /dev/null +++ b/dynamic_theme/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings @@ -0,0 +1,8 @@ + + + + + PreviewsEnabled + + + diff --git a/dynamic_theme/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/dynamic_theme/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 00000000000..8e3ca5dfe19 --- /dev/null +++ b/dynamic_theme/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dynamic_theme/ios/Runner.xcworkspace/contents.xcworkspacedata b/dynamic_theme/ios/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 00000000000..1d526a16ed0 --- /dev/null +++ b/dynamic_theme/ios/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/dynamic_theme/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/dynamic_theme/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/dynamic_theme/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/dynamic_theme/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings b/dynamic_theme/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings new file mode 100644 index 00000000000..f9b0d7c5ea1 --- /dev/null +++ b/dynamic_theme/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings @@ -0,0 +1,8 @@ + + + + + PreviewsEnabled + + + diff --git a/dynamic_theme/ios/Runner/AppDelegate.swift b/dynamic_theme/ios/Runner/AppDelegate.swift new file mode 100644 index 00000000000..70693e4a8c1 --- /dev/null +++ b/dynamic_theme/ios/Runner/AppDelegate.swift @@ -0,0 +1,13 @@ +import UIKit +import Flutter + +@UIApplicationMain +@objc class AppDelegate: FlutterAppDelegate { + override func application( + _ application: UIApplication, + didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? + ) -> Bool { + GeneratedPluginRegistrant.register(with: self) + return super.application(application, didFinishLaunchingWithOptions: launchOptions) + } +} diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 00000000000..d36b1fab2d9 --- /dev/null +++ b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,122 @@ +{ + "images" : [ + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-App-20x20@2x.png", + "scale" : "2x" + }, + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-App-20x20@3x.png", + "scale" : "3x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@1x.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@3x.png", + "scale" : "3x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-App-40x40@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-App-40x40@3x.png", + "scale" : "3x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-App-60x60@2x.png", + "scale" : "2x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-App-60x60@3x.png", + "scale" : "3x" + }, + { + "size" : "20x20", + "idiom" : "ipad", + "filename" : "Icon-App-20x20@1x.png", + "scale" : "1x" + }, + { + "size" : "20x20", + "idiom" : "ipad", + "filename" : "Icon-App-20x20@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "ipad", + "filename" : "Icon-App-29x29@1x.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "ipad", + "filename" : "Icon-App-29x29@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "ipad", + "filename" : "Icon-App-40x40@1x.png", + "scale" : "1x" + }, + { + "size" : "40x40", + "idiom" : "ipad", + "filename" : "Icon-App-40x40@2x.png", + "scale" : "2x" + }, + { + "size" : "76x76", + "idiom" : "ipad", + "filename" : "Icon-App-76x76@1x.png", + "scale" : "1x" + }, + { + "size" : "76x76", + "idiom" : "ipad", + "filename" : "Icon-App-76x76@2x.png", + "scale" : "2x" + }, + { + "size" : "83.5x83.5", + "idiom" : "ipad", + "filename" : "Icon-App-83.5x83.5@2x.png", + "scale" : "2x" + }, + { + "size" : "1024x1024", + "idiom" : "ios-marketing", + "filename" : "Icon-App-1024x1024@1x.png", + "scale" : "1x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png new file mode 100644 index 00000000000..dc9ada4725e Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png new file mode 100644 index 00000000000..7353c41ecf9 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png new file mode 100644 index 00000000000..797d452e458 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png new file mode 100644 index 00000000000..6ed2d933e11 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png new file mode 100644 index 00000000000..4cd7b0099ca Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png new file mode 100644 index 00000000000..fe730945a01 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png new file mode 100644 index 00000000000..321773cd857 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png new file mode 100644 index 00000000000..797d452e458 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png new file mode 100644 index 00000000000..502f463a9bc Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png new file mode 100644 index 00000000000..0ec30343922 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png new file mode 100644 index 00000000000..0ec30343922 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png new file mode 100644 index 00000000000..e9f5fea27c7 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png new file mode 100644 index 00000000000..84ac32ae7d9 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png new file mode 100644 index 00000000000..8953cba0906 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png new file mode 100644 index 00000000000..0467bf12aa4 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json new file mode 100644 index 00000000000..0bedcf2fd46 --- /dev/null +++ b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json @@ -0,0 +1,23 @@ +{ + "images" : [ + { + "idiom" : "universal", + "filename" : "LaunchImage.png", + "scale" : "1x" + }, + { + "idiom" : "universal", + "filename" : "LaunchImage@2x.png", + "scale" : "2x" + }, + { + "idiom" : "universal", + "filename" : "LaunchImage@3x.png", + "scale" : "3x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png new file mode 100644 index 00000000000..9da19eacad3 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png new file mode 100644 index 00000000000..9da19eacad3 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png new file mode 100644 index 00000000000..9da19eacad3 Binary files /dev/null and b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png differ diff --git a/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md new file mode 100644 index 00000000000..89c2725b70f --- /dev/null +++ b/dynamic_theme/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md @@ -0,0 +1,5 @@ +# Launch Screen Assets + +You can customize the launch screen with your own desired assets by replacing the image files in this directory. + +You can also do it by opening your Flutter project's Xcode project with `open ios/Runner.xcworkspace`, selecting `Runner/Assets.xcassets` in the Project Navigator and dropping in the desired images. \ No newline at end of file diff --git a/dynamic_theme/ios/Runner/Base.lproj/LaunchScreen.storyboard b/dynamic_theme/ios/Runner/Base.lproj/LaunchScreen.storyboard new file mode 100644 index 00000000000..f2e259c7c93 --- /dev/null +++ b/dynamic_theme/ios/Runner/Base.lproj/LaunchScreen.storyboard @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dynamic_theme/ios/Runner/Base.lproj/Main.storyboard b/dynamic_theme/ios/Runner/Base.lproj/Main.storyboard new file mode 100644 index 00000000000..f3c28516fb3 --- /dev/null +++ b/dynamic_theme/ios/Runner/Base.lproj/Main.storyboard @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dynamic_theme/ios/Runner/Info.plist b/dynamic_theme/ios/Runner/Info.plist new file mode 100644 index 00000000000..5c12ce8d007 --- /dev/null +++ b/dynamic_theme/ios/Runner/Info.plist @@ -0,0 +1,49 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleDisplayName + Dynamic Theme + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + dynamic_theme + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleSignature + ???? + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSRequiresIPhoneOS + + UILaunchStoryboardName + LaunchScreen + UIMainStoryboardFile + Main + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + CADisableMinimumFrameDurationOnPhone + + UIApplicationSupportsIndirectInputEvents + + + diff --git a/dynamic_theme/ios/Runner/Runner-Bridging-Header.h b/dynamic_theme/ios/Runner/Runner-Bridging-Header.h new file mode 100644 index 00000000000..308a2a560b4 --- /dev/null +++ b/dynamic_theme/ios/Runner/Runner-Bridging-Header.h @@ -0,0 +1 @@ +#import "GeneratedPluginRegistrant.h" diff --git a/dynamic_theme/ios/RunnerTests/RunnerTests.swift b/dynamic_theme/ios/RunnerTests/RunnerTests.swift new file mode 100644 index 00000000000..86a7c3b1b61 --- /dev/null +++ b/dynamic_theme/ios/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import Flutter +import UIKit +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/dynamic_theme/lib/main.dart b/dynamic_theme/lib/main.dart new file mode 100644 index 00000000000..f80110a3cce --- /dev/null +++ b/dynamic_theme/lib/main.dart @@ -0,0 +1,338 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import 'dart:async'; + +import 'package:flutter/material.dart'; +import 'package:google_generative_ai/google_generative_ai.dart'; + +import 'widgets/api_key_widget.dart'; +import 'widgets/message_widget.dart'; +import 'widgets/text_field_decoration.dart'; + +final themeColor = ValueNotifier(Colors.orangeAccent); +final themeMode = ValueNotifier(ThemeMode.light); +final textScaleFactor = ValueNotifier(1); + +void main() { + runApp(const GenerativeAISample(title: "Dynamic Theme")); +} + +class GenerativeAISample extends StatefulWidget { + const GenerativeAISample({super.key, required this.title}); + final String title; + + @override + State createState() => _GenerativeAISampleState(); +} + +class _GenerativeAISampleState extends State { + String? apiKey; + + ThemeData theme(Brightness brightness) { + final colors = ColorScheme.fromSeed( + brightness: brightness, + seedColor: themeColor.value, + ); + return ThemeData( + brightness: brightness, + colorScheme: colors, + scaffoldBackgroundColor: colors.surface, + ); + } + + @override + Widget build(BuildContext context) { + return AnimatedBuilder( + animation: Listenable.merge([ + themeColor, + themeMode, + textScaleFactor, + ]), + builder: (context, child) { + return MaterialApp( + debugShowCheckedModeBanner: false, + title: 'Flutter + GenAI', + theme: theme(Brightness.light), + darkTheme: theme(Brightness.dark), + themeMode: themeMode.value, + builder: (context, child) { + return MediaQuery( + data: MediaQuery.of(context).copyWith( + textScaler: TextScaler.linear(textScaleFactor.value)), + child: child!, + ); + }, + home: switch (apiKey) { + final providedKey? => Example( + title: widget.title, + apiKey: providedKey, + ), + _ => ApiKeyWidget( + title: widget.title, + onSubmitted: (key) { + setState(() => apiKey = key); + }, + ), + }, + ); + }, + ); + } +} + +class Example extends StatefulWidget { + const Example({ + super.key, + required this.apiKey, + required this.title, + }); + + final String apiKey, title; + + @override + State createState() => _ExampleState(); +} + +class _ExampleState extends State { + final loading = ValueNotifier(false); + final menu = ValueNotifier(''); + final messages = ValueNotifier>([]); + final controller = TextEditingController(); + late final _history = []; + + late final model = GenerativeModel( + model: 'gemini-pro', + apiKey: widget.apiKey, + requestOptions: const RequestOptions(apiVersion: 'v1beta'), + tools: [ + Tool( + functionDeclarations: [ + FunctionDeclaration( + 'change_theme_color', + 'Change the current theme color', + Schema( + SchemaType.object, + properties: { + 'hex': Schema( + SchemaType.string, + description: 'Must be 6 in length. FF00EE,000000,FFFFFF', + ), + }, + ), + ), + FunctionDeclaration( + 'change_theme_mode', + 'Change the current theme mode', + Schema( + SchemaType.object, + properties: { + 'mode': Schema( + SchemaType.string, + description: + 'Must be one of the following: light,dark,system', + ), + }, + ), + ), + FunctionDeclaration( + 'change_text_scale_factor', + 'Change the current font scale, where 1 represents 14px and 2.0 = 48px', + Schema( + SchemaType.object, + properties: { + 'scale': Schema( + SchemaType.number, + description: 'Valid font scale, defaults to 1.0', + ), + }, + ), + ), + ], + ), + ], + ); + + Future sendMessage() async { + final message = controller.text.trim(); + if (message.isEmpty) return; + controller.clear(); + addMessage(Sender.user, message); + loading.value = true; + try { + final prompt = StringBuffer(); + // prompt.writeln( + // 'If the following is not a question assume' + // 'it is a new task to be added:', + // ); + prompt.writeln(message); + final response = await callWithActions([Content.text(prompt.toString())]); + if (response.text != null) { + addMessage(Sender.system, response.text!); + } else { + addMessage(Sender.system, 'Something went wrong, please try again.'); + } + } catch (e) { + addMessage(Sender.system, 'Error sending message: $e'); + } finally { + loading.value = false; + } + } + + Future callWithActions( + Iterable prompt, + ) async { + final response = await model.generateContent( + _history.followedBy(prompt), + ); + if (response.candidates.isNotEmpty) { + _history.addAll(prompt); + _history.add(response.candidates.first.content); + } + final actions = []; + for (final fn in response.functionCalls) { + final args = fn.args; + switch (fn.name) { + case 'change_theme_color': + final hex = args['hex'] as String; + if (hex.length != 6) { + actions.add(FunctionResponse(fn.name, { + 'type': 'Error', + 'message': 'hex must be exactly 6 characters', + })); + } else { + themeColor.value = Color(int.parse('0xFF$hex')); + actions.add(FunctionResponse(fn.name, { + 'type': 'Success', + 'message': 'theme color updated', + })); + } + break; + case 'change_theme_mode': + final mode = args['mode'] as String; + themeMode.value = switch (mode) { + 'system' => ThemeMode.system, + 'light' => ThemeMode.light, + 'dark' => ThemeMode.dark, + (_) => ThemeMode.system, + }; + actions.add(FunctionResponse(fn.name, { + 'type': 'Success', + 'message': 'theme mode updated', + })); + break; + case 'change_text_scale_factor': + final value = args['scale'] as num; + textScaleFactor.value = value.toDouble(); + actions.add(FunctionResponse(fn.name, { + 'type': 'Success', + 'message': 'font scale updated', + })); + break; + default: + } + } + if (actions.isNotEmpty) { + return await callWithActions([ + ...prompt, + if (response.functionCalls.isNotEmpty) + Content.model(response.functionCalls), + for (final res in actions) + Content.functionResponse(res.name, res.response), + ]); + } + return response; + } + + void addMessage(Sender sender, String value, {bool clear = false}) { + if (clear) { + _history.clear(); + messages.value = []; + } + messages.value = messages.value.toList()..add((sender, value)); + } + + @override + Widget build(BuildContext context) { + return AnimatedBuilder( + animation: messages, + builder: (context, child) { + final reversed = messages.value.reversed; + return Scaffold( + appBar: AppBar( + title: Text(widget.title), + ), + body: messages.value.isEmpty + ? const Center( + child: Padding( + padding: EdgeInsets.all(32.0), + child: Text('Start changing the theme! Try typing ' + 'in requests like "Make the colors darker" or "Make the ' + 'font larger" and see what happens.'), + ), + ) + : ListView.builder( + padding: const EdgeInsets.all(8), + reverse: true, + itemCount: reversed.length, + itemBuilder: (context, index) { + final (sender, message) = reversed.elementAt(index); + return MessageWidget( + isFromUser: sender == Sender.user, + text: message, + ); + }, + ), + bottomNavigationBar: BottomAppBar( + padding: const EdgeInsets.all(8), + child: Row( + children: [ + Expanded( + child: TextField( + controller: controller, + decoration: textFieldDecoration( + context, + 'Change the theme color, font scale factor or brightness', + ), + onEditingComplete: sendMessage, + onSubmitted: (value) => sendMessage(), + ), + ), + const SizedBox(width: 8), + AnimatedBuilder( + animation: loading, + builder: (context, _) { + if (loading.value) { + return const CircularProgressIndicator(); + } + return IconButton( + onPressed: sendMessage, + icon: const Icon(Icons.send), + tooltip: 'Send a message', + ); + }, + ), + ], + ), + ), + ); + }, + ); + } +} + +enum Sender { + user, + system, +} diff --git a/dynamic_theme/lib/widgets/api_key_widget.dart b/dynamic_theme/lib/widgets/api_key_widget.dart new file mode 100644 index 00000000000..244d922b823 --- /dev/null +++ b/dynamic_theme/lib/widgets/api_key_widget.dart @@ -0,0 +1,88 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import 'package:flutter/material.dart'; +import 'package:url_launcher/link.dart'; + +import 'text_field_decoration.dart'; + +class ApiKeyWidget extends StatelessWidget { + ApiKeyWidget({ + super.key, + required this.onSubmitted, + required this.title, + }); + + final String title; + final ValueChanged onSubmitted; + final _textController = TextEditingController(); + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text(title), + ), + body: Center( + child: Padding( + padding: const EdgeInsets.all(8.0), + child: Column( + mainAxisSize: MainAxisSize.min, + children: [ + const Text( + 'To use the Gemini API, you\'ll need an API key. ' + 'If you don\'t already have one, ' + 'create a key in Google AI Studio.', + textAlign: TextAlign.center, + ), + const SizedBox(height: 8), + Link( + uri: Uri.https('aistudio.google.com', '/app/apikey'), + target: LinkTarget.blank, + builder: (context, followLink) => TextButton( + onPressed: followLink, + child: const Text('Get an API Key'), + ), + ), + ], + ), + ), + ), + bottomNavigationBar: BottomAppBar( + padding: const EdgeInsets.all(8), + child: Row( + children: [ + Expanded( + child: TextField( + decoration: textFieldDecoration(context, 'Enter your API key'), + controller: _textController, + obscureText: true, + onSubmitted: (value) { + onSubmitted(value); + }, + ), + ), + const SizedBox(height: 8), + TextButton( + onPressed: () { + onSubmitted(_textController.value.text); + }, + child: const Text('Submit'), + ), + ], + ), + ), + ); + } +} diff --git a/dynamic_theme/lib/widgets/message_widget.dart b/dynamic_theme/lib/widgets/message_widget.dart new file mode 100644 index 00000000000..3aac0f9db70 --- /dev/null +++ b/dynamic_theme/lib/widgets/message_widget.dart @@ -0,0 +1,59 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import 'package:flutter/material.dart'; +import 'package:flutter_markdown/flutter_markdown.dart'; + +class MessageWidget extends StatelessWidget { + const MessageWidget({ + super.key, + this.text, + this.image, + required this.isFromUser, + }); + + final Image? image; + final String? text; + final bool isFromUser; + + @override + Widget build(BuildContext context) { + return Row( + mainAxisAlignment: + isFromUser ? MainAxisAlignment.end : MainAxisAlignment.start, + children: [ + Flexible( + child: Container( + constraints: const BoxConstraints(maxWidth: 520), + decoration: BoxDecoration( + color: isFromUser + ? Theme.of(context).colorScheme.primaryContainer + : Theme.of(context).colorScheme.surfaceVariant, + borderRadius: BorderRadius.circular(18), + ), + padding: const EdgeInsets.symmetric( + vertical: 15, + horizontal: 20, + ), + margin: const EdgeInsets.only(bottom: 8), + child: Column(children: [ + if (text case final text?) MarkdownBody(data: text), + if (image case final image?) image, + ]), + ), + ), + ], + ); + } +} diff --git a/dynamic_theme/lib/widgets/text_field_decoration.dart b/dynamic_theme/lib/widgets/text_field_decoration.dart new file mode 100644 index 00000000000..cdc9abd37bc --- /dev/null +++ b/dynamic_theme/lib/widgets/text_field_decoration.dart @@ -0,0 +1,38 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import 'package:flutter/material.dart'; + +InputDecoration textFieldDecoration(BuildContext context, String hintText) { + return InputDecoration( + contentPadding: const EdgeInsets.all(15), + hintText: hintText, + border: OutlineInputBorder( + borderRadius: const BorderRadius.all( + Radius.circular(14), + ), + borderSide: BorderSide( + color: Theme.of(context).colorScheme.secondary, + ), + ), + focusedBorder: OutlineInputBorder( + borderRadius: const BorderRadius.all( + Radius.circular(14), + ), + borderSide: BorderSide( + color: Theme.of(context).colorScheme.secondary, + ), + ), + ); +} diff --git a/dynamic_theme/linux/.gitignore b/dynamic_theme/linux/.gitignore new file mode 100644 index 00000000000..d3896c98444 --- /dev/null +++ b/dynamic_theme/linux/.gitignore @@ -0,0 +1 @@ +flutter/ephemeral diff --git a/dynamic_theme/linux/CMakeLists.txt b/dynamic_theme/linux/CMakeLists.txt new file mode 100644 index 00000000000..9513c1fee13 --- /dev/null +++ b/dynamic_theme/linux/CMakeLists.txt @@ -0,0 +1,145 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.10) +project(runner LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "dynamic_theme") +# The unique GTK application identifier for this application. See: +# https://wiki.gnome.org/HowDoI/ChooseApplicationID +set(APPLICATION_ID "com.example.dynamic_theme") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(SET CMP0063 NEW) + +# Load bundled libraries from the lib/ directory relative to the binary. +set(CMAKE_INSTALL_RPATH "$ORIGIN/lib") + +# Root filesystem for cross-building. +if(FLUTTER_TARGET_PLATFORM_SYSROOT) + set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endif() + +# Define build configuration options. +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") +endif() + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_14) + target_compile_options(${TARGET} PRIVATE -Wall -Werror) + target_compile_options(${TARGET} PRIVATE "$<$>:-O3>") + target_compile_definitions(${TARGET} PRIVATE "$<$>:NDEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) + +add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}") + +# Define the application target. To change its name, change BINARY_NAME above, +# not the value here, or `flutter run` will no longer work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} + "main.cc" + "my_application.cc" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add dependency libraries. Add any application-specific dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter) +target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK) + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) + +# Only the install-generated bundle's copy of the executable will launch +# correctly, since the resources must in the right relative locations. To avoid +# people trying to run the unbundled copy, put it in a subdirectory instead of +# the default top-level location. +set_target_properties(${BINARY_NAME} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run" +) + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# By default, "installing" just makes a relocatable bundle in the build +# directory. +set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle") +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +# Start with a clean build bundle directory every time. +install(CODE " + file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\") + " COMPONENT Runtime) + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES}) + install(FILES "${bundled_library}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endforeach(bundled_library) + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +if(NOT CMAKE_BUILD_TYPE MATCHES "Debug") + install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() diff --git a/dynamic_theme/linux/flutter/CMakeLists.txt b/dynamic_theme/linux/flutter/CMakeLists.txt new file mode 100644 index 00000000000..d5bd01648a9 --- /dev/null +++ b/dynamic_theme/linux/flutter/CMakeLists.txt @@ -0,0 +1,88 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.10) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. + +# Serves the same purpose as list(TRANSFORM ... PREPEND ...), +# which isn't available in 3.10. +function(list_prepend LIST_NAME PREFIX) + set(NEW_LIST "") + foreach(element ${${LIST_NAME}}) + list(APPEND NEW_LIST "${PREFIX}${element}") + endforeach(element) + set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE) +endfunction() + +# === Flutter Library === +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) +pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0) +pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0) + +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "fl_basic_message_channel.h" + "fl_binary_codec.h" + "fl_binary_messenger.h" + "fl_dart_project.h" + "fl_engine.h" + "fl_json_message_codec.h" + "fl_json_method_codec.h" + "fl_message_codec.h" + "fl_method_call.h" + "fl_method_channel.h" + "fl_method_codec.h" + "fl_method_response.h" + "fl_plugin_registrar.h" + "fl_plugin_registry.h" + "fl_standard_message_codec.h" + "fl_standard_method_codec.h" + "fl_string_codec.h" + "fl_value.h" + "fl_view.h" + "flutter_linux.h" +) +list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}") +target_link_libraries(flutter INTERFACE + PkgConfig::GTK + PkgConfig::GLIB + PkgConfig::GIO +) +add_dependencies(flutter flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CMAKE_CURRENT_BINARY_DIR}/_phony_ + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh" + ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE} + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} +) diff --git a/dynamic_theme/linux/flutter/generated_plugin_registrant.cc b/dynamic_theme/linux/flutter/generated_plugin_registrant.cc new file mode 100644 index 00000000000..f6f23bfe970 --- /dev/null +++ b/dynamic_theme/linux/flutter/generated_plugin_registrant.cc @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + +#include + +void fl_register_plugins(FlPluginRegistry* registry) { + g_autoptr(FlPluginRegistrar) url_launcher_linux_registrar = + fl_plugin_registry_get_registrar_for_plugin(registry, "UrlLauncherPlugin"); + url_launcher_plugin_register_with_registrar(url_launcher_linux_registrar); +} diff --git a/dynamic_theme/linux/flutter/generated_plugin_registrant.h b/dynamic_theme/linux/flutter/generated_plugin_registrant.h new file mode 100644 index 00000000000..e0f0a47bc08 --- /dev/null +++ b/dynamic_theme/linux/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void fl_register_plugins(FlPluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/dynamic_theme/linux/flutter/generated_plugins.cmake b/dynamic_theme/linux/flutter/generated_plugins.cmake new file mode 100644 index 00000000000..f16b4c34213 --- /dev/null +++ b/dynamic_theme/linux/flutter/generated_plugins.cmake @@ -0,0 +1,24 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST + url_launcher_linux +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/dynamic_theme/linux/main.cc b/dynamic_theme/linux/main.cc new file mode 100644 index 00000000000..e7c5c543703 --- /dev/null +++ b/dynamic_theme/linux/main.cc @@ -0,0 +1,6 @@ +#include "my_application.h" + +int main(int argc, char** argv) { + g_autoptr(MyApplication) app = my_application_new(); + return g_application_run(G_APPLICATION(app), argc, argv); +} diff --git a/dynamic_theme/linux/my_application.cc b/dynamic_theme/linux/my_application.cc new file mode 100644 index 00000000000..42581a3295f --- /dev/null +++ b/dynamic_theme/linux/my_application.cc @@ -0,0 +1,124 @@ +#include "my_application.h" + +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#include "flutter/generated_plugin_registrant.h" + +struct _MyApplication { + GtkApplication parent_instance; + char** dart_entrypoint_arguments; +}; + +G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION) + +// Implements GApplication::activate. +static void my_application_activate(GApplication* application) { + MyApplication* self = MY_APPLICATION(application); + GtkWindow* window = + GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application))); + + // Use a header bar when running in GNOME as this is the common style used + // by applications and is the setup most users will be using (e.g. Ubuntu + // desktop). + // If running on X and not using GNOME then just use a traditional title bar + // in case the window manager does more exotic layout, e.g. tiling. + // If running on Wayland assume the header bar will work (may need changing + // if future cases occur). + gboolean use_header_bar = TRUE; +#ifdef GDK_WINDOWING_X11 + GdkScreen* screen = gtk_window_get_screen(window); + if (GDK_IS_X11_SCREEN(screen)) { + const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen); + if (g_strcmp0(wm_name, "GNOME Shell") != 0) { + use_header_bar = FALSE; + } + } +#endif + if (use_header_bar) { + GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new()); + gtk_widget_show(GTK_WIDGET(header_bar)); + gtk_header_bar_set_title(header_bar, "dynamic_theme"); + gtk_header_bar_set_show_close_button(header_bar, TRUE); + gtk_window_set_titlebar(window, GTK_WIDGET(header_bar)); + } else { + gtk_window_set_title(window, "dynamic_theme"); + } + + gtk_window_set_default_size(window, 1280, 720); + gtk_widget_show(GTK_WIDGET(window)); + + g_autoptr(FlDartProject) project = fl_dart_project_new(); + fl_dart_project_set_dart_entrypoint_arguments(project, self->dart_entrypoint_arguments); + + FlView* view = fl_view_new(project); + gtk_widget_show(GTK_WIDGET(view)); + gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view)); + + fl_register_plugins(FL_PLUGIN_REGISTRY(view)); + + gtk_widget_grab_focus(GTK_WIDGET(view)); +} + +// Implements GApplication::local_command_line. +static gboolean my_application_local_command_line(GApplication* application, gchar*** arguments, int* exit_status) { + MyApplication* self = MY_APPLICATION(application); + // Strip out the first argument as it is the binary name. + self->dart_entrypoint_arguments = g_strdupv(*arguments + 1); + + g_autoptr(GError) error = nullptr; + if (!g_application_register(application, nullptr, &error)) { + g_warning("Failed to register: %s", error->message); + *exit_status = 1; + return TRUE; + } + + g_application_activate(application); + *exit_status = 0; + + return TRUE; +} + +// Implements GApplication::startup. +static void my_application_startup(GApplication* application) { + //MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application startup. + + G_APPLICATION_CLASS(my_application_parent_class)->startup(application); +} + +// Implements GApplication::shutdown. +static void my_application_shutdown(GApplication* application) { + //MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application shutdown. + + G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application); +} + +// Implements GObject::dispose. +static void my_application_dispose(GObject* object) { + MyApplication* self = MY_APPLICATION(object); + g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev); + G_OBJECT_CLASS(my_application_parent_class)->dispose(object); +} + +static void my_application_class_init(MyApplicationClass* klass) { + G_APPLICATION_CLASS(klass)->activate = my_application_activate; + G_APPLICATION_CLASS(klass)->local_command_line = my_application_local_command_line; + G_APPLICATION_CLASS(klass)->startup = my_application_startup; + G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown; + G_OBJECT_CLASS(klass)->dispose = my_application_dispose; +} + +static void my_application_init(MyApplication* self) {} + +MyApplication* my_application_new() { + return MY_APPLICATION(g_object_new(my_application_get_type(), + "application-id", APPLICATION_ID, + "flags", G_APPLICATION_NON_UNIQUE, + nullptr)); +} diff --git a/dynamic_theme/linux/my_application.h b/dynamic_theme/linux/my_application.h new file mode 100644 index 00000000000..72271d5e417 --- /dev/null +++ b/dynamic_theme/linux/my_application.h @@ -0,0 +1,18 @@ +#ifndef FLUTTER_MY_APPLICATION_H_ +#define FLUTTER_MY_APPLICATION_H_ + +#include + +G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION, + GtkApplication) + +/** + * my_application_new: + * + * Creates a new Flutter-based application. + * + * Returns: a new #MyApplication. + */ +MyApplication* my_application_new(); + +#endif // FLUTTER_MY_APPLICATION_H_ diff --git a/dynamic_theme/macos/.gitignore b/dynamic_theme/macos/.gitignore new file mode 100644 index 00000000000..746adbb6b9e --- /dev/null +++ b/dynamic_theme/macos/.gitignore @@ -0,0 +1,7 @@ +# Flutter-related +**/Flutter/ephemeral/ +**/Pods/ + +# Xcode-related +**/dgph +**/xcuserdata/ diff --git a/dynamic_theme/macos/Flutter/Flutter-Debug.xcconfig b/dynamic_theme/macos/Flutter/Flutter-Debug.xcconfig new file mode 100644 index 00000000000..4b81f9b2d20 --- /dev/null +++ b/dynamic_theme/macos/Flutter/Flutter-Debug.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig" +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/dynamic_theme/macos/Flutter/Flutter-Release.xcconfig b/dynamic_theme/macos/Flutter/Flutter-Release.xcconfig new file mode 100644 index 00000000000..5caa9d1579e --- /dev/null +++ b/dynamic_theme/macos/Flutter/Flutter-Release.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig" +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/dynamic_theme/macos/Flutter/GeneratedPluginRegistrant.swift b/dynamic_theme/macos/Flutter/GeneratedPluginRegistrant.swift new file mode 100644 index 00000000000..8236f5728c6 --- /dev/null +++ b/dynamic_theme/macos/Flutter/GeneratedPluginRegistrant.swift @@ -0,0 +1,12 @@ +// +// Generated file. Do not edit. +// + +import FlutterMacOS +import Foundation + +import url_launcher_macos + +func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) { + UrlLauncherPlugin.register(with: registry.registrar(forPlugin: "UrlLauncherPlugin")) +} diff --git a/dynamic_theme/macos/Podfile b/dynamic_theme/macos/Podfile new file mode 100644 index 00000000000..c795730db8e --- /dev/null +++ b/dynamic_theme/macos/Podfile @@ -0,0 +1,43 @@ +platform :osx, '10.14' + +# CocoaPods analytics sends network stats synchronously affecting flutter build latency. +ENV['COCOAPODS_DISABLE_STATS'] = 'true' + +project 'Runner', { + 'Debug' => :debug, + 'Profile' => :release, + 'Release' => :release, +} + +def flutter_root + generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'ephemeral', 'Flutter-Generated.xcconfig'), __FILE__) + unless File.exist?(generated_xcode_build_settings_path) + raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure \"flutter pub get\" is executed first" + end + + File.foreach(generated_xcode_build_settings_path) do |line| + matches = line.match(/FLUTTER_ROOT\=(.*)/) + return matches[1].strip if matches + end + raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Flutter-Generated.xcconfig, then run \"flutter pub get\"" +end + +require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root) + +flutter_macos_podfile_setup + +target 'Runner' do + use_frameworks! + use_modular_headers! + + flutter_install_all_macos_pods File.dirname(File.realpath(__FILE__)) + target 'RunnerTests' do + inherit! :search_paths + end +end + +post_install do |installer| + installer.pods_project.targets.each do |target| + flutter_additional_macos_build_settings(target) + end +end diff --git a/dynamic_theme/macos/Runner.xcodeproj/project.pbxproj b/dynamic_theme/macos/Runner.xcodeproj/project.pbxproj new file mode 100644 index 00000000000..b721a4d701c --- /dev/null +++ b/dynamic_theme/macos/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,801 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXAggregateTarget section */ + 33CC111A2044C6BA0003C045 /* Flutter Assemble */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */; + buildPhases = ( + 33CC111E2044C6BF0003C045 /* ShellScript */, + ); + dependencies = ( + ); + name = "Flutter Assemble"; + productName = FLX; + }; +/* End PBXAggregateTarget section */ + +/* Begin PBXBuildFile section */ + 287400A9EC44776F28F31C8B /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F611F1DAB08D867D504D2407 /* Pods_Runner.framework */; }; + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C80D7294CF71000263BE5 /* RunnerTests.swift */; }; + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */ = {isa = PBXBuildFile; fileRef = 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */; }; + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC10F02044A3C60003C045 /* AppDelegate.swift */; }; + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F22044A3C60003C045 /* Assets.xcassets */; }; + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F42044A3C60003C045 /* MainMenu.xib */; }; + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */; }; + 38A802307A0201EDBB2C58C9 /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4170BAFD4359164F659F06F1 /* Pods_RunnerTests.framework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC10EC2044A3C60003C045; + remoteInfo = Runner; + }; + 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC111A2044C6BA0003C045; + remoteInfo = FLX; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 33CC110E2044A8840003C045 /* Bundle Framework */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Bundle Framework"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 074D69953D38FB6B6E70DC7F /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = ""; }; + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 331C80D7294CF71000263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Warnings.xcconfig; sourceTree = ""; }; + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GeneratedPluginRegistrant.swift; sourceTree = ""; }; + 33CC10ED2044A3C60003C045 /* dynamic_theme.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = dynamic_theme.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 33CC10F02044A3C60003C045 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 33CC10F22044A3C60003C045 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Assets.xcassets; path = Runner/Assets.xcassets; sourceTree = ""; }; + 33CC10F52044A3C60003C045 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MainMenu.xib; sourceTree = ""; }; + 33CC10F72044A3C60003C045 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Info.plist; path = Runner/Info.plist; sourceTree = ""; }; + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainFlutterWindow.swift; sourceTree = ""; }; + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Debug.xcconfig"; sourceTree = ""; }; + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Release.xcconfig"; sourceTree = ""; }; + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "Flutter-Generated.xcconfig"; path = "ephemeral/Flutter-Generated.xcconfig"; sourceTree = ""; }; + 33E51913231747F40026EE4D /* DebugProfile.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = DebugProfile.entitlements; sourceTree = ""; }; + 33E51914231749380026EE4D /* Release.entitlements */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.entitlements; path = Release.entitlements; sourceTree = ""; }; + 33E5194F232828860026EE4D /* AppInfo.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AppInfo.xcconfig; sourceTree = ""; }; + 349503D317120280E2182111 /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = ""; }; + 39A5D88C395E17065C59851E /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = ""; }; + 4170BAFD4359164F659F06F1 /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 55939BEA737967F00783DD37 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = ""; }; + 953CC1AD9E1D46640495B652 /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = ""; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = ""; }; + BE61068ACA732E778B5B2ABD /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = ""; }; + F611F1DAB08D867D504D2407 /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 331C80D2294CF70F00263BE5 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 38A802307A0201EDBB2C58C9 /* Pods_RunnerTests.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EA2044A3C60003C045 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 287400A9EC44776F28F31C8B /* Pods_Runner.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 331C80D6294CF71000263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C80D7294CF71000263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 33BA886A226E78AF003329D5 /* Configs */ = { + isa = PBXGroup; + children = ( + 33E5194F232828860026EE4D /* AppInfo.xcconfig */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */, + ); + path = Configs; + sourceTree = ""; + }; + 33CC10E42044A3C60003C045 = { + isa = PBXGroup; + children = ( + 33FAB671232836740065AC1E /* Runner */, + 33CEB47122A05771004F2AC0 /* Flutter */, + 331C80D6294CF71000263BE5 /* RunnerTests */, + 33CC10EE2044A3C60003C045 /* Products */, + D73912EC22F37F3D000D13A0 /* Frameworks */, + 8B2D8D0F2F909F62010B5D76 /* Pods */, + ); + sourceTree = ""; + }; + 33CC10EE2044A3C60003C045 /* Products */ = { + isa = PBXGroup; + children = ( + 33CC10ED2044A3C60003C045 /* dynamic_theme.app */, + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 33CC11242044D66E0003C045 /* Resources */ = { + isa = PBXGroup; + children = ( + 33CC10F22044A3C60003C045 /* Assets.xcassets */, + 33CC10F42044A3C60003C045 /* MainMenu.xib */, + 33CC10F72044A3C60003C045 /* Info.plist */, + ); + name = Resources; + path = ..; + sourceTree = ""; + }; + 33CEB47122A05771004F2AC0 /* Flutter */ = { + isa = PBXGroup; + children = ( + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */, + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */, + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */, + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */, + ); + path = Flutter; + sourceTree = ""; + }; + 33FAB671232836740065AC1E /* Runner */ = { + isa = PBXGroup; + children = ( + 33CC10F02044A3C60003C045 /* AppDelegate.swift */, + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */, + 33E51913231747F40026EE4D /* DebugProfile.entitlements */, + 33E51914231749380026EE4D /* Release.entitlements */, + 33CC11242044D66E0003C045 /* Resources */, + 33BA886A226E78AF003329D5 /* Configs */, + ); + path = Runner; + sourceTree = ""; + }; + 8B2D8D0F2F909F62010B5D76 /* Pods */ = { + isa = PBXGroup; + children = ( + 55939BEA737967F00783DD37 /* Pods-Runner.debug.xcconfig */, + 074D69953D38FB6B6E70DC7F /* Pods-Runner.release.xcconfig */, + 349503D317120280E2182111 /* Pods-Runner.profile.xcconfig */, + 39A5D88C395E17065C59851E /* Pods-RunnerTests.debug.xcconfig */, + 953CC1AD9E1D46640495B652 /* Pods-RunnerTests.release.xcconfig */, + BE61068ACA732E778B5B2ABD /* Pods-RunnerTests.profile.xcconfig */, + ); + name = Pods; + path = Pods; + sourceTree = ""; + }; + D73912EC22F37F3D000D13A0 /* Frameworks */ = { + isa = PBXGroup; + children = ( + F611F1DAB08D867D504D2407 /* Pods_Runner.framework */, + 4170BAFD4359164F659F06F1 /* Pods_RunnerTests.framework */, + ); + name = Frameworks; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C80D4294CF70F00263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 607A24ADA552BBD79106FAC7 /* [CP] Check Pods Manifest.lock */, + 331C80D1294CF70F00263BE5 /* Sources */, + 331C80D2294CF70F00263BE5 /* Frameworks */, + 331C80D3294CF70F00263BE5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 331C80DA294CF71000263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C80D5294CF71000263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 33CC10EC2044A3C60003C045 /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + 1B535C1F2FFC6320A18ED712 /* [CP] Check Pods Manifest.lock */, + 33CC10E92044A3C60003C045 /* Sources */, + 33CC10EA2044A3C60003C045 /* Frameworks */, + 33CC10EB2044A3C60003C045 /* Resources */, + 33CC110E2044A8840003C045 /* Bundle Framework */, + 3399D490228B24CF009A79C7 /* ShellScript */, + 097842B7F7E558D94D9B134A /* [CP] Embed Pods Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 33CC11202044C79F0003C045 /* PBXTargetDependency */, + ); + name = Runner; + productName = Runner; + productReference = 33CC10ED2044A3C60003C045 /* dynamic_theme.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 33CC10E52044A3C60003C045 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastSwiftUpdateCheck = 0920; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C80D4294CF70F00263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 33CC10EC2044A3C60003C045; + }; + 33CC10EC2044A3C60003C045 = { + CreatedOnToolsVersion = 9.2; + LastSwiftMigration = 1100; + ProvisioningStyle = Automatic; + SystemCapabilities = { + com.apple.Sandbox = { + enabled = 1; + }; + }; + }; + 33CC111A2044C6BA0003C045 = { + CreatedOnToolsVersion = 9.2; + ProvisioningStyle = Manual; + }; + }; + }; + buildConfigurationList = 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 33CC10E42044A3C60003C045; + productRefGroup = 33CC10EE2044A3C60003C045 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 33CC10EC2044A3C60003C045 /* Runner */, + 331C80D4294CF70F00263BE5 /* RunnerTests */, + 33CC111A2044C6BA0003C045 /* Flutter Assemble */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C80D3294CF70F00263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EB2044A3C60003C045 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */, + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 097842B7F7E558D94D9B134A /* [CP] Embed Pods Frameworks */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist", + ); + name = "[CP] Embed Pods Frameworks"; + outputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n"; + showEnvVarsInLog = 0; + }; + 1B535C1F2FFC6320A18ED712 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-Runner-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; + 3399D490228B24CF009A79C7 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "echo \"$PRODUCT_NAME.app\" > \"$PROJECT_DIR\"/Flutter/ephemeral/.app_filename && \"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh embed\n"; + }; + 33CC111E2044C6BF0003C045 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + Flutter/ephemeral/FlutterInputs.xcfilelist, + ); + inputPaths = ( + Flutter/ephemeral/tripwire, + ); + outputFileListPaths = ( + Flutter/ephemeral/FlutterOutputs.xcfilelist, + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh && touch Flutter/ephemeral/tripwire"; + }; + 607A24ADA552BBD79106FAC7 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-RunnerTests-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C80D1294CF70F00263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10E92044A3C60003C045 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */, + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */, + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C80DA294CF71000263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC10EC2044A3C60003C045 /* Runner */; + targetProxy = 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */; + }; + 33CC11202044C79F0003C045 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC111A2044C6BA0003C045 /* Flutter Assemble */; + targetProxy = 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 33CC10F42044A3C60003C045 /* MainMenu.xib */ = { + isa = PBXVariantGroup; + children = ( + 33CC10F52044A3C60003C045 /* Base */, + ); + name = MainMenu.xib; + path = Runner; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 331C80DB294CF71000263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 39A5D88C395E17065C59851E /* Pods-RunnerTests.debug.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/dynamic_theme.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/dynamic_theme"; + }; + name = Debug; + }; + 331C80DC294CF71000263BE5 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 953CC1AD9E1D46640495B652 /* Pods-RunnerTests.release.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/dynamic_theme.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/dynamic_theme"; + }; + name = Release; + }; + 331C80DD294CF71000263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = BE61068ACA732E778B5B2ABD /* Pods-RunnerTests.profile.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/dynamic_theme.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/dynamic_theme"; + }; + name = Profile; + }; + 338D0CE9231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Profile; + }; + 338D0CEA231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Profile; + }; + 338D0CEB231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Profile; + }; + 33CC10F92044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + 33CC10FA2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Release; + }; + 33CC10FC2044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + }; + name = Debug; + }; + 33CC10FD2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/Release.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Release; + }; + 33CC111C2044C6BA0003C045 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 33CC111D2044C6BA0003C045 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C80DB294CF71000263BE5 /* Debug */, + 331C80DC294CF71000263BE5 /* Release */, + 331C80DD294CF71000263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10F92044A3C60003C045 /* Debug */, + 33CC10FA2044A3C60003C045 /* Release */, + 338D0CE9231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10FC2044A3C60003C045 /* Debug */, + 33CC10FD2044A3C60003C045 /* Release */, + 338D0CEA231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC111C2044C6BA0003C045 /* Debug */, + 33CC111D2044C6BA0003C045 /* Release */, + 338D0CEB231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 33CC10E52044A3C60003C045 /* Project object */; +} diff --git a/dynamic_theme/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/dynamic_theme/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/dynamic_theme/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/dynamic_theme/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/dynamic_theme/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 00000000000..a8d7ef3634c --- /dev/null +++ b/dynamic_theme/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dynamic_theme/macos/Runner.xcworkspace/contents.xcworkspacedata b/dynamic_theme/macos/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 00000000000..21a3cc14c74 --- /dev/null +++ b/dynamic_theme/macos/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,10 @@ + + + + + + + diff --git a/dynamic_theme/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/dynamic_theme/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/dynamic_theme/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/dynamic_theme/macos/Runner/AppDelegate.swift b/dynamic_theme/macos/Runner/AppDelegate.swift new file mode 100644 index 00000000000..d53ef643772 --- /dev/null +++ b/dynamic_theme/macos/Runner/AppDelegate.swift @@ -0,0 +1,9 @@ +import Cocoa +import FlutterMacOS + +@NSApplicationMain +class AppDelegate: FlutterAppDelegate { + override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { + return true + } +} diff --git a/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 00000000000..a2ec33f19f1 --- /dev/null +++ b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,68 @@ +{ + "images" : [ + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_16.png", + "scale" : "1x" + }, + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "2x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "1x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_64.png", + "scale" : "2x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_128.png", + "scale" : "1x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "2x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "1x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "2x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "1x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_1024.png", + "scale" : "2x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png new file mode 100644 index 00000000000..82b6f9d9a33 Binary files /dev/null and b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png differ diff --git a/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png new file mode 100644 index 00000000000..13b35eba55c Binary files /dev/null and b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png differ diff --git a/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png new file mode 100644 index 00000000000..0a3f5fa40fb Binary files /dev/null and b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png differ diff --git a/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png new file mode 100644 index 00000000000..bdb57226d5f Binary files /dev/null and b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png differ diff --git a/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png new file mode 100644 index 00000000000..f083318e09c Binary files /dev/null and b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png differ diff --git a/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png new file mode 100644 index 00000000000..326c0e72c9d Binary files /dev/null and b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png differ diff --git a/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png new file mode 100644 index 00000000000..2f1632cfddf Binary files /dev/null and b/dynamic_theme/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png differ diff --git a/dynamic_theme/macos/Runner/Base.lproj/MainMenu.xib b/dynamic_theme/macos/Runner/Base.lproj/MainMenu.xib new file mode 100644 index 00000000000..80e867a4e06 --- /dev/null +++ b/dynamic_theme/macos/Runner/Base.lproj/MainMenu.xib @@ -0,0 +1,343 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dynamic_theme/macos/Runner/Configs/AppInfo.xcconfig b/dynamic_theme/macos/Runner/Configs/AppInfo.xcconfig new file mode 100644 index 00000000000..c2d79fa66cd --- /dev/null +++ b/dynamic_theme/macos/Runner/Configs/AppInfo.xcconfig @@ -0,0 +1,14 @@ +// Application-level settings for the Runner target. +// +// This may be replaced with something auto-generated from metadata (e.g., pubspec.yaml) in the +// future. If not, the values below would default to using the project name when this becomes a +// 'flutter create' template. + +// The application's name. By default this is also the title of the Flutter window. +PRODUCT_NAME = dynamic_theme + +// The application's bundle identifier +PRODUCT_BUNDLE_IDENTIFIER = com.example.dynamicTheme + +// The copyright displayed in application information +PRODUCT_COPYRIGHT = Copyright © 2024 com.example. All rights reserved. diff --git a/dynamic_theme/macos/Runner/Configs/Debug.xcconfig b/dynamic_theme/macos/Runner/Configs/Debug.xcconfig new file mode 100644 index 00000000000..36b0fd9464f --- /dev/null +++ b/dynamic_theme/macos/Runner/Configs/Debug.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Debug.xcconfig" +#include "Warnings.xcconfig" diff --git a/dynamic_theme/macos/Runner/Configs/Release.xcconfig b/dynamic_theme/macos/Runner/Configs/Release.xcconfig new file mode 100644 index 00000000000..dff4f49561c --- /dev/null +++ b/dynamic_theme/macos/Runner/Configs/Release.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Release.xcconfig" +#include "Warnings.xcconfig" diff --git a/dynamic_theme/macos/Runner/Configs/Warnings.xcconfig b/dynamic_theme/macos/Runner/Configs/Warnings.xcconfig new file mode 100644 index 00000000000..42bcbf4780b --- /dev/null +++ b/dynamic_theme/macos/Runner/Configs/Warnings.xcconfig @@ -0,0 +1,13 @@ +WARNING_CFLAGS = -Wall -Wconditional-uninitialized -Wnullable-to-nonnull-conversion -Wmissing-method-return-type -Woverlength-strings +GCC_WARN_UNDECLARED_SELECTOR = YES +CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES +CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE +CLANG_WARN__DUPLICATE_METHOD_MATCH = YES +CLANG_WARN_PRAGMA_PACK = YES +CLANG_WARN_STRICT_PROTOTYPES = YES +CLANG_WARN_COMMA = YES +GCC_WARN_STRICT_SELECTOR_MATCH = YES +CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK = YES +CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES +GCC_WARN_SHADOW = YES +CLANG_WARN_UNREACHABLE_CODE = YES diff --git a/dynamic_theme/macos/Runner/DebugProfile.entitlements b/dynamic_theme/macos/Runner/DebugProfile.entitlements new file mode 100644 index 00000000000..08c3ab17cc2 --- /dev/null +++ b/dynamic_theme/macos/Runner/DebugProfile.entitlements @@ -0,0 +1,14 @@ + + + + + com.apple.security.app-sandbox + + com.apple.security.cs.allow-jit + + com.apple.security.network.server + + com.apple.security.network.client + + + diff --git a/dynamic_theme/macos/Runner/Info.plist b/dynamic_theme/macos/Runner/Info.plist new file mode 100644 index 00000000000..4789daa6a44 --- /dev/null +++ b/dynamic_theme/macos/Runner/Info.plist @@ -0,0 +1,32 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIconFile + + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSMinimumSystemVersion + $(MACOSX_DEPLOYMENT_TARGET) + NSHumanReadableCopyright + $(PRODUCT_COPYRIGHT) + NSMainNibFile + MainMenu + NSPrincipalClass + NSApplication + + diff --git a/dynamic_theme/macos/Runner/MainFlutterWindow.swift b/dynamic_theme/macos/Runner/MainFlutterWindow.swift new file mode 100644 index 00000000000..3cc05eb2349 --- /dev/null +++ b/dynamic_theme/macos/Runner/MainFlutterWindow.swift @@ -0,0 +1,15 @@ +import Cocoa +import FlutterMacOS + +class MainFlutterWindow: NSWindow { + override func awakeFromNib() { + let flutterViewController = FlutterViewController() + let windowFrame = self.frame + self.contentViewController = flutterViewController + self.setFrame(windowFrame, display: true) + + RegisterGeneratedPlugins(registry: flutterViewController) + + super.awakeFromNib() + } +} diff --git a/dynamic_theme/macos/Runner/Release.entitlements b/dynamic_theme/macos/Runner/Release.entitlements new file mode 100644 index 00000000000..852fa1a4728 --- /dev/null +++ b/dynamic_theme/macos/Runner/Release.entitlements @@ -0,0 +1,8 @@ + + + + + com.apple.security.app-sandbox + + + diff --git a/dynamic_theme/macos/RunnerTests/RunnerTests.swift b/dynamic_theme/macos/RunnerTests/RunnerTests.swift new file mode 100644 index 00000000000..5418c9f5395 --- /dev/null +++ b/dynamic_theme/macos/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import FlutterMacOS +import Cocoa +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/dynamic_theme/pubspec.yaml b/dynamic_theme/pubspec.yaml new file mode 100644 index 00000000000..ac67b7ed454 --- /dev/null +++ b/dynamic_theme/pubspec.yaml @@ -0,0 +1,22 @@ +name: dynamic_theme +description: "Sample app for the google_generative_ai package" +publish_to: 'none' +version: 1.0.0+1 +environment: + sdk: '>=3.3.0 <4.0.0' + +dependencies: + flutter: + sdk: flutter + flutter_markdown: ^0.7.1 + google_generative_ai: ^0.3.3 + url_launcher: ^6.2.6 + +dev_dependencies: + flutter_test: + sdk: flutter + flutter_lints: ^3.0.0 + +flutter: + uses-material-design: true + diff --git a/dynamic_theme/web/favicon.png b/dynamic_theme/web/favicon.png new file mode 100644 index 00000000000..8aaa46ac1ae Binary files /dev/null and b/dynamic_theme/web/favicon.png differ diff --git a/dynamic_theme/web/icons/Icon-192.png b/dynamic_theme/web/icons/Icon-192.png new file mode 100644 index 00000000000..b749bfef074 Binary files /dev/null and b/dynamic_theme/web/icons/Icon-192.png differ diff --git a/dynamic_theme/web/icons/Icon-512.png b/dynamic_theme/web/icons/Icon-512.png new file mode 100644 index 00000000000..88cfd48dff1 Binary files /dev/null and b/dynamic_theme/web/icons/Icon-512.png differ diff --git a/dynamic_theme/web/icons/Icon-maskable-192.png b/dynamic_theme/web/icons/Icon-maskable-192.png new file mode 100644 index 00000000000..eb9b4d76e52 Binary files /dev/null and b/dynamic_theme/web/icons/Icon-maskable-192.png differ diff --git a/dynamic_theme/web/icons/Icon-maskable-512.png b/dynamic_theme/web/icons/Icon-maskable-512.png new file mode 100644 index 00000000000..d69c56691fb Binary files /dev/null and b/dynamic_theme/web/icons/Icon-maskable-512.png differ diff --git a/dynamic_theme/web/index.html b/dynamic_theme/web/index.html new file mode 100644 index 00000000000..8e702997062 --- /dev/null +++ b/dynamic_theme/web/index.html @@ -0,0 +1,59 @@ + + + + + + + + + + + + + + + + + + + + dynamic_theme + + + + + + + + + + diff --git a/dynamic_theme/web/manifest.json b/dynamic_theme/web/manifest.json new file mode 100644 index 00000000000..712cd4d750a --- /dev/null +++ b/dynamic_theme/web/manifest.json @@ -0,0 +1,35 @@ +{ + "name": "dynamic_theme", + "short_name": "dynamic_theme", + "start_url": ".", + "display": "standalone", + "background_color": "#0175C2", + "theme_color": "#0175C2", + "description": "A new Flutter project.", + "orientation": "portrait-primary", + "prefer_related_applications": false, + "icons": [ + { + "src": "icons/Icon-192.png", + "sizes": "192x192", + "type": "image/png" + }, + { + "src": "icons/Icon-512.png", + "sizes": "512x512", + "type": "image/png" + }, + { + "src": "icons/Icon-maskable-192.png", + "sizes": "192x192", + "type": "image/png", + "purpose": "maskable" + }, + { + "src": "icons/Icon-maskable-512.png", + "sizes": "512x512", + "type": "image/png", + "purpose": "maskable" + } + ] +} diff --git a/dynamic_theme/windows/.gitignore b/dynamic_theme/windows/.gitignore new file mode 100644 index 00000000000..d492d0d98c8 --- /dev/null +++ b/dynamic_theme/windows/.gitignore @@ -0,0 +1,17 @@ +flutter/ephemeral/ + +# Visual Studio user-specific files. +*.suo +*.user +*.userosscache +*.sln.docstates + +# Visual Studio build-related files. +x64/ +x86/ + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ diff --git a/dynamic_theme/windows/CMakeLists.txt b/dynamic_theme/windows/CMakeLists.txt new file mode 100644 index 00000000000..640f58e8e59 --- /dev/null +++ b/dynamic_theme/windows/CMakeLists.txt @@ -0,0 +1,108 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.14) +project(dynamic_theme LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "dynamic_theme") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(VERSION 3.14...3.25) + +# Define build configuration option. +get_property(IS_MULTICONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +if(IS_MULTICONFIG) + set(CMAKE_CONFIGURATION_TYPES "Debug;Profile;Release" + CACHE STRING "" FORCE) +else() + if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") + endif() +endif() +# Define settings for the Profile build mode. +set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}") +set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}") +set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE}") +set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE}") + +# Use Unicode for all projects. +add_definitions(-DUNICODE -D_UNICODE) + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_17) + target_compile_options(${TARGET} PRIVATE /W4 /WX /wd"4100") + target_compile_options(${TARGET} PRIVATE /EHsc) + target_compile_definitions(${TARGET} PRIVATE "_HAS_EXCEPTIONS=0") + target_compile_definitions(${TARGET} PRIVATE "$<$:_DEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# Application build; see runner/CMakeLists.txt. +add_subdirectory("runner") + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# Support files are copied into place next to the executable, so that it can +# run in place. This is done instead of making a separate bundle (as on Linux) +# so that building and running from within Visual Studio will work. +set(BUILD_BUNDLE_DIR "$") +# Make the "install" step default, as it's required to run. +set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1) +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +if(PLUGIN_BUNDLED_LIBRARIES) + install(FILES "${PLUGIN_BUNDLED_LIBRARIES}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/windows/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + CONFIGURATIONS Profile;Release + COMPONENT Runtime) diff --git a/dynamic_theme/windows/flutter/CMakeLists.txt b/dynamic_theme/windows/flutter/CMakeLists.txt new file mode 100644 index 00000000000..903f4899d6f --- /dev/null +++ b/dynamic_theme/windows/flutter/CMakeLists.txt @@ -0,0 +1,109 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.14) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. +set(WRAPPER_ROOT "${EPHEMERAL_DIR}/cpp_client_wrapper") + +# Set fallback configurations for older versions of the flutter tool. +if (NOT DEFINED FLUTTER_TARGET_PLATFORM) + set(FLUTTER_TARGET_PLATFORM "windows-x64") +endif() + +# === Flutter Library === +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/flutter_windows.dll") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/windows/app.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "flutter_export.h" + "flutter_windows.h" + "flutter_messenger.h" + "flutter_plugin_registrar.h" + "flutter_texture_registrar.h" +) +list(TRANSFORM FLUTTER_LIBRARY_HEADERS PREPEND "${EPHEMERAL_DIR}/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}.lib") +add_dependencies(flutter flutter_assemble) + +# === Wrapper === +list(APPEND CPP_WRAPPER_SOURCES_CORE + "core_implementations.cc" + "standard_codec.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_CORE PREPEND "${WRAPPER_ROOT}/") +list(APPEND CPP_WRAPPER_SOURCES_PLUGIN + "plugin_registrar.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_PLUGIN PREPEND "${WRAPPER_ROOT}/") +list(APPEND CPP_WRAPPER_SOURCES_APP + "flutter_engine.cc" + "flutter_view_controller.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/") + +# Wrapper sources needed for a plugin. +add_library(flutter_wrapper_plugin STATIC + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_PLUGIN} +) +apply_standard_settings(flutter_wrapper_plugin) +set_target_properties(flutter_wrapper_plugin PROPERTIES + POSITION_INDEPENDENT_CODE ON) +set_target_properties(flutter_wrapper_plugin PROPERTIES + CXX_VISIBILITY_PRESET hidden) +target_link_libraries(flutter_wrapper_plugin PUBLIC flutter) +target_include_directories(flutter_wrapper_plugin PUBLIC + "${WRAPPER_ROOT}/include" +) +add_dependencies(flutter_wrapper_plugin flutter_assemble) + +# Wrapper sources needed for the runner. +add_library(flutter_wrapper_app STATIC + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_APP} +) +apply_standard_settings(flutter_wrapper_app) +target_link_libraries(flutter_wrapper_app PUBLIC flutter) +target_include_directories(flutter_wrapper_app PUBLIC + "${WRAPPER_ROOT}/include" +) +add_dependencies(flutter_wrapper_app flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +set(PHONY_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/_phony_") +set_source_files_properties("${PHONY_OUTPUT}" PROPERTIES SYMBOLIC TRUE) +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN} + ${CPP_WRAPPER_SOURCES_APP} + ${PHONY_OUTPUT} + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.bat" + ${FLUTTER_TARGET_PLATFORM} $ + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_PLUGIN} + ${CPP_WRAPPER_SOURCES_APP} +) diff --git a/dynamic_theme/windows/flutter/generated_plugin_registrant.cc b/dynamic_theme/windows/flutter/generated_plugin_registrant.cc new file mode 100644 index 00000000000..4f7884874da --- /dev/null +++ b/dynamic_theme/windows/flutter/generated_plugin_registrant.cc @@ -0,0 +1,14 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + +#include + +void RegisterPlugins(flutter::PluginRegistry* registry) { + UrlLauncherWindowsRegisterWithRegistrar( + registry->GetRegistrarForPlugin("UrlLauncherWindows")); +} diff --git a/dynamic_theme/windows/flutter/generated_plugin_registrant.h b/dynamic_theme/windows/flutter/generated_plugin_registrant.h new file mode 100644 index 00000000000..dc139d85a93 --- /dev/null +++ b/dynamic_theme/windows/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void RegisterPlugins(flutter::PluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/dynamic_theme/windows/flutter/generated_plugins.cmake b/dynamic_theme/windows/flutter/generated_plugins.cmake new file mode 100644 index 00000000000..88b22e5c775 --- /dev/null +++ b/dynamic_theme/windows/flutter/generated_plugins.cmake @@ -0,0 +1,24 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST + url_launcher_windows +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/windows plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/dynamic_theme/windows/runner/CMakeLists.txt b/dynamic_theme/windows/runner/CMakeLists.txt new file mode 100644 index 00000000000..394917c053a --- /dev/null +++ b/dynamic_theme/windows/runner/CMakeLists.txt @@ -0,0 +1,40 @@ +cmake_minimum_required(VERSION 3.14) +project(runner LANGUAGES CXX) + +# Define the application target. To change its name, change BINARY_NAME in the +# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer +# work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} WIN32 + "flutter_window.cpp" + "main.cpp" + "utils.cpp" + "win32_window.cpp" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" + "Runner.rc" + "runner.exe.manifest" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add preprocessor definitions for the build version. +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION=\"${FLUTTER_VERSION}\"") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MAJOR=${FLUTTER_VERSION_MAJOR}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MINOR=${FLUTTER_VERSION_MINOR}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_PATCH=${FLUTTER_VERSION_PATCH}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_BUILD=${FLUTTER_VERSION_BUILD}") + +# Disable Windows macros that collide with C++ standard library functions. +target_compile_definitions(${BINARY_NAME} PRIVATE "NOMINMAX") + +# Add dependency libraries and include directories. Add any application-specific +# dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter flutter_wrapper_app) +target_link_libraries(${BINARY_NAME} PRIVATE "dwmapi.lib") +target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}") + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) diff --git a/dynamic_theme/windows/runner/Runner.rc b/dynamic_theme/windows/runner/Runner.rc new file mode 100644 index 00000000000..b71f4dfad24 --- /dev/null +++ b/dynamic_theme/windows/runner/Runner.rc @@ -0,0 +1,121 @@ +// Microsoft Visual C++ generated resource script. +// +#pragma code_page(65001) +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (United States) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_APP_ICON ICON "resources\\app_icon.ico" + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +#if defined(FLUTTER_VERSION_MAJOR) && defined(FLUTTER_VERSION_MINOR) && defined(FLUTTER_VERSION_PATCH) && defined(FLUTTER_VERSION_BUILD) +#define VERSION_AS_NUMBER FLUTTER_VERSION_MAJOR,FLUTTER_VERSION_MINOR,FLUTTER_VERSION_PATCH,FLUTTER_VERSION_BUILD +#else +#define VERSION_AS_NUMBER 1,0,0,0 +#endif + +#if defined(FLUTTER_VERSION) +#define VERSION_AS_STRING FLUTTER_VERSION +#else +#define VERSION_AS_STRING "1.0.0" +#endif + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VERSION_AS_NUMBER + PRODUCTVERSION VERSION_AS_NUMBER + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK +#ifdef _DEBUG + FILEFLAGS VS_FF_DEBUG +#else + FILEFLAGS 0x0L +#endif + FILEOS VOS__WINDOWS32 + FILETYPE VFT_APP + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904e4" + BEGIN + VALUE "CompanyName", "com.example" "\0" + VALUE "FileDescription", "dynamic_theme" "\0" + VALUE "FileVersion", VERSION_AS_STRING "\0" + VALUE "InternalName", "dynamic_theme" "\0" + VALUE "LegalCopyright", "Copyright (C) 2024 com.example. All rights reserved." "\0" + VALUE "OriginalFilename", "dynamic_theme.exe" "\0" + VALUE "ProductName", "dynamic_theme" "\0" + VALUE "ProductVersion", VERSION_AS_STRING "\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1252 + END +END + +#endif // English (United States) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED diff --git a/dynamic_theme/windows/runner/flutter_window.cpp b/dynamic_theme/windows/runner/flutter_window.cpp new file mode 100644 index 00000000000..955ee3038f9 --- /dev/null +++ b/dynamic_theme/windows/runner/flutter_window.cpp @@ -0,0 +1,71 @@ +#include "flutter_window.h" + +#include + +#include "flutter/generated_plugin_registrant.h" + +FlutterWindow::FlutterWindow(const flutter::DartProject& project) + : project_(project) {} + +FlutterWindow::~FlutterWindow() {} + +bool FlutterWindow::OnCreate() { + if (!Win32Window::OnCreate()) { + return false; + } + + RECT frame = GetClientArea(); + + // The size here must match the window dimensions to avoid unnecessary surface + // creation / destruction in the startup path. + flutter_controller_ = std::make_unique( + frame.right - frame.left, frame.bottom - frame.top, project_); + // Ensure that basic setup of the controller was successful. + if (!flutter_controller_->engine() || !flutter_controller_->view()) { + return false; + } + RegisterPlugins(flutter_controller_->engine()); + SetChildContent(flutter_controller_->view()->GetNativeWindow()); + + flutter_controller_->engine()->SetNextFrameCallback([&]() { + this->Show(); + }); + + // Flutter can complete the first frame before the "show window" callback is + // registered. The following call ensures a frame is pending to ensure the + // window is shown. It is a no-op if the first frame hasn't completed yet. + flutter_controller_->ForceRedraw(); + + return true; +} + +void FlutterWindow::OnDestroy() { + if (flutter_controller_) { + flutter_controller_ = nullptr; + } + + Win32Window::OnDestroy(); +} + +LRESULT +FlutterWindow::MessageHandler(HWND hwnd, UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + // Give Flutter, including plugins, an opportunity to handle window messages. + if (flutter_controller_) { + std::optional result = + flutter_controller_->HandleTopLevelWindowProc(hwnd, message, wparam, + lparam); + if (result) { + return *result; + } + } + + switch (message) { + case WM_FONTCHANGE: + flutter_controller_->engine()->ReloadSystemFonts(); + break; + } + + return Win32Window::MessageHandler(hwnd, message, wparam, lparam); +} diff --git a/dynamic_theme/windows/runner/flutter_window.h b/dynamic_theme/windows/runner/flutter_window.h new file mode 100644 index 00000000000..6da0652f05f --- /dev/null +++ b/dynamic_theme/windows/runner/flutter_window.h @@ -0,0 +1,33 @@ +#ifndef RUNNER_FLUTTER_WINDOW_H_ +#define RUNNER_FLUTTER_WINDOW_H_ + +#include +#include + +#include + +#include "win32_window.h" + +// A window that does nothing but host a Flutter view. +class FlutterWindow : public Win32Window { + public: + // Creates a new FlutterWindow hosting a Flutter view running |project|. + explicit FlutterWindow(const flutter::DartProject& project); + virtual ~FlutterWindow(); + + protected: + // Win32Window: + bool OnCreate() override; + void OnDestroy() override; + LRESULT MessageHandler(HWND window, UINT const message, WPARAM const wparam, + LPARAM const lparam) noexcept override; + + private: + // The project to run. + flutter::DartProject project_; + + // The Flutter instance hosted by this window. + std::unique_ptr flutter_controller_; +}; + +#endif // RUNNER_FLUTTER_WINDOW_H_ diff --git a/dynamic_theme/windows/runner/main.cpp b/dynamic_theme/windows/runner/main.cpp new file mode 100644 index 00000000000..99ca144cfe9 --- /dev/null +++ b/dynamic_theme/windows/runner/main.cpp @@ -0,0 +1,43 @@ +#include +#include +#include + +#include "flutter_window.h" +#include "utils.h" + +int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev, + _In_ wchar_t *command_line, _In_ int show_command) { + // Attach to console when present (e.g., 'flutter run') or create a + // new console when running with a debugger. + if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) { + CreateAndAttachConsole(); + } + + // Initialize COM, so that it is available for use in the library and/or + // plugins. + ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED); + + flutter::DartProject project(L"data"); + + std::vector command_line_arguments = + GetCommandLineArguments(); + + project.set_dart_entrypoint_arguments(std::move(command_line_arguments)); + + FlutterWindow window(project); + Win32Window::Point origin(10, 10); + Win32Window::Size size(1280, 720); + if (!window.Create(L"dynamic_theme", origin, size)) { + return EXIT_FAILURE; + } + window.SetQuitOnClose(true); + + ::MSG msg; + while (::GetMessage(&msg, nullptr, 0, 0)) { + ::TranslateMessage(&msg); + ::DispatchMessage(&msg); + } + + ::CoUninitialize(); + return EXIT_SUCCESS; +} diff --git a/dynamic_theme/windows/runner/resource.h b/dynamic_theme/windows/runner/resource.h new file mode 100644 index 00000000000..66a65d1e4a7 --- /dev/null +++ b/dynamic_theme/windows/runner/resource.h @@ -0,0 +1,16 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by Runner.rc +// +#define IDI_APP_ICON 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 102 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/dynamic_theme/windows/runner/resources/app_icon.ico b/dynamic_theme/windows/runner/resources/app_icon.ico new file mode 100644 index 00000000000..c04e20caf63 Binary files /dev/null and b/dynamic_theme/windows/runner/resources/app_icon.ico differ diff --git a/dynamic_theme/windows/runner/runner.exe.manifest b/dynamic_theme/windows/runner/runner.exe.manifest new file mode 100644 index 00000000000..a42ea7687cb --- /dev/null +++ b/dynamic_theme/windows/runner/runner.exe.manifest @@ -0,0 +1,20 @@ + + + + + PerMonitorV2 + + + + + + + + + + + + + + + diff --git a/dynamic_theme/windows/runner/utils.cpp b/dynamic_theme/windows/runner/utils.cpp new file mode 100644 index 00000000000..b2b08734db2 --- /dev/null +++ b/dynamic_theme/windows/runner/utils.cpp @@ -0,0 +1,65 @@ +#include "utils.h" + +#include +#include +#include +#include + +#include + +void CreateAndAttachConsole() { + if (::AllocConsole()) { + FILE *unused; + if (freopen_s(&unused, "CONOUT$", "w", stdout)) { + _dup2(_fileno(stdout), 1); + } + if (freopen_s(&unused, "CONOUT$", "w", stderr)) { + _dup2(_fileno(stdout), 2); + } + std::ios::sync_with_stdio(); + FlutterDesktopResyncOutputStreams(); + } +} + +std::vector GetCommandLineArguments() { + // Convert the UTF-16 command line arguments to UTF-8 for the Engine to use. + int argc; + wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc); + if (argv == nullptr) { + return std::vector(); + } + + std::vector command_line_arguments; + + // Skip the first argument as it's the binary name. + for (int i = 1; i < argc; i++) { + command_line_arguments.push_back(Utf8FromUtf16(argv[i])); + } + + ::LocalFree(argv); + + return command_line_arguments; +} + +std::string Utf8FromUtf16(const wchar_t* utf16_string) { + if (utf16_string == nullptr) { + return std::string(); + } + int target_length = ::WideCharToMultiByte( + CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, + -1, nullptr, 0, nullptr, nullptr) + -1; // remove the trailing null character + int input_length = (int)wcslen(utf16_string); + std::string utf8_string; + if (target_length <= 0 || target_length > utf8_string.max_size()) { + return utf8_string; + } + utf8_string.resize(target_length); + int converted_length = ::WideCharToMultiByte( + CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, + input_length, utf8_string.data(), target_length, nullptr, nullptr); + if (converted_length == 0) { + return std::string(); + } + return utf8_string; +} diff --git a/dynamic_theme/windows/runner/utils.h b/dynamic_theme/windows/runner/utils.h new file mode 100644 index 00000000000..3879d547557 --- /dev/null +++ b/dynamic_theme/windows/runner/utils.h @@ -0,0 +1,19 @@ +#ifndef RUNNER_UTILS_H_ +#define RUNNER_UTILS_H_ + +#include +#include + +// Creates a console for the process, and redirects stdout and stderr to +// it for both the runner and the Flutter library. +void CreateAndAttachConsole(); + +// Takes a null-terminated wchar_t* encoded in UTF-16 and returns a std::string +// encoded in UTF-8. Returns an empty std::string on failure. +std::string Utf8FromUtf16(const wchar_t* utf16_string); + +// Gets the command line arguments passed in as a std::vector, +// encoded in UTF-8. Returns an empty std::vector on failure. +std::vector GetCommandLineArguments(); + +#endif // RUNNER_UTILS_H_ diff --git a/dynamic_theme/windows/runner/win32_window.cpp b/dynamic_theme/windows/runner/win32_window.cpp new file mode 100644 index 00000000000..60608d0fe5b --- /dev/null +++ b/dynamic_theme/windows/runner/win32_window.cpp @@ -0,0 +1,288 @@ +#include "win32_window.h" + +#include +#include + +#include "resource.h" + +namespace { + +/// Window attribute that enables dark mode window decorations. +/// +/// Redefined in case the developer's machine has a Windows SDK older than +/// version 10.0.22000.0. +/// See: https://docs.microsoft.com/windows/win32/api/dwmapi/ne-dwmapi-dwmwindowattribute +#ifndef DWMWA_USE_IMMERSIVE_DARK_MODE +#define DWMWA_USE_IMMERSIVE_DARK_MODE 20 +#endif + +constexpr const wchar_t kWindowClassName[] = L"FLUTTER_RUNNER_WIN32_WINDOW"; + +/// Registry key for app theme preference. +/// +/// A value of 0 indicates apps should use dark mode. A non-zero or missing +/// value indicates apps should use light mode. +constexpr const wchar_t kGetPreferredBrightnessRegKey[] = + L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize"; +constexpr const wchar_t kGetPreferredBrightnessRegValue[] = L"AppsUseLightTheme"; + +// The number of Win32Window objects that currently exist. +static int g_active_window_count = 0; + +using EnableNonClientDpiScaling = BOOL __stdcall(HWND hwnd); + +// Scale helper to convert logical scaler values to physical using passed in +// scale factor +int Scale(int source, double scale_factor) { + return static_cast(source * scale_factor); +} + +// Dynamically loads the |EnableNonClientDpiScaling| from the User32 module. +// This API is only needed for PerMonitor V1 awareness mode. +void EnableFullDpiSupportIfAvailable(HWND hwnd) { + HMODULE user32_module = LoadLibraryA("User32.dll"); + if (!user32_module) { + return; + } + auto enable_non_client_dpi_scaling = + reinterpret_cast( + GetProcAddress(user32_module, "EnableNonClientDpiScaling")); + if (enable_non_client_dpi_scaling != nullptr) { + enable_non_client_dpi_scaling(hwnd); + } + FreeLibrary(user32_module); +} + +} // namespace + +// Manages the Win32Window's window class registration. +class WindowClassRegistrar { + public: + ~WindowClassRegistrar() = default; + + // Returns the singleton registrar instance. + static WindowClassRegistrar* GetInstance() { + if (!instance_) { + instance_ = new WindowClassRegistrar(); + } + return instance_; + } + + // Returns the name of the window class, registering the class if it hasn't + // previously been registered. + const wchar_t* GetWindowClass(); + + // Unregisters the window class. Should only be called if there are no + // instances of the window. + void UnregisterWindowClass(); + + private: + WindowClassRegistrar() = default; + + static WindowClassRegistrar* instance_; + + bool class_registered_ = false; +}; + +WindowClassRegistrar* WindowClassRegistrar::instance_ = nullptr; + +const wchar_t* WindowClassRegistrar::GetWindowClass() { + if (!class_registered_) { + WNDCLASS window_class{}; + window_class.hCursor = LoadCursor(nullptr, IDC_ARROW); + window_class.lpszClassName = kWindowClassName; + window_class.style = CS_HREDRAW | CS_VREDRAW; + window_class.cbClsExtra = 0; + window_class.cbWndExtra = 0; + window_class.hInstance = GetModuleHandle(nullptr); + window_class.hIcon = + LoadIcon(window_class.hInstance, MAKEINTRESOURCE(IDI_APP_ICON)); + window_class.hbrBackground = 0; + window_class.lpszMenuName = nullptr; + window_class.lpfnWndProc = Win32Window::WndProc; + RegisterClass(&window_class); + class_registered_ = true; + } + return kWindowClassName; +} + +void WindowClassRegistrar::UnregisterWindowClass() { + UnregisterClass(kWindowClassName, nullptr); + class_registered_ = false; +} + +Win32Window::Win32Window() { + ++g_active_window_count; +} + +Win32Window::~Win32Window() { + --g_active_window_count; + Destroy(); +} + +bool Win32Window::Create(const std::wstring& title, + const Point& origin, + const Size& size) { + Destroy(); + + const wchar_t* window_class = + WindowClassRegistrar::GetInstance()->GetWindowClass(); + + const POINT target_point = {static_cast(origin.x), + static_cast(origin.y)}; + HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST); + UINT dpi = FlutterDesktopGetDpiForMonitor(monitor); + double scale_factor = dpi / 96.0; + + HWND window = CreateWindow( + window_class, title.c_str(), WS_OVERLAPPEDWINDOW, + Scale(origin.x, scale_factor), Scale(origin.y, scale_factor), + Scale(size.width, scale_factor), Scale(size.height, scale_factor), + nullptr, nullptr, GetModuleHandle(nullptr), this); + + if (!window) { + return false; + } + + UpdateTheme(window); + + return OnCreate(); +} + +bool Win32Window::Show() { + return ShowWindow(window_handle_, SW_SHOWNORMAL); +} + +// static +LRESULT CALLBACK Win32Window::WndProc(HWND const window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + if (message == WM_NCCREATE) { + auto window_struct = reinterpret_cast(lparam); + SetWindowLongPtr(window, GWLP_USERDATA, + reinterpret_cast(window_struct->lpCreateParams)); + + auto that = static_cast(window_struct->lpCreateParams); + EnableFullDpiSupportIfAvailable(window); + that->window_handle_ = window; + } else if (Win32Window* that = GetThisFromHandle(window)) { + return that->MessageHandler(window, message, wparam, lparam); + } + + return DefWindowProc(window, message, wparam, lparam); +} + +LRESULT +Win32Window::MessageHandler(HWND hwnd, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + switch (message) { + case WM_DESTROY: + window_handle_ = nullptr; + Destroy(); + if (quit_on_close_) { + PostQuitMessage(0); + } + return 0; + + case WM_DPICHANGED: { + auto newRectSize = reinterpret_cast(lparam); + LONG newWidth = newRectSize->right - newRectSize->left; + LONG newHeight = newRectSize->bottom - newRectSize->top; + + SetWindowPos(hwnd, nullptr, newRectSize->left, newRectSize->top, newWidth, + newHeight, SWP_NOZORDER | SWP_NOACTIVATE); + + return 0; + } + case WM_SIZE: { + RECT rect = GetClientArea(); + if (child_content_ != nullptr) { + // Size and position the child window. + MoveWindow(child_content_, rect.left, rect.top, rect.right - rect.left, + rect.bottom - rect.top, TRUE); + } + return 0; + } + + case WM_ACTIVATE: + if (child_content_ != nullptr) { + SetFocus(child_content_); + } + return 0; + + case WM_DWMCOLORIZATIONCOLORCHANGED: + UpdateTheme(hwnd); + return 0; + } + + return DefWindowProc(window_handle_, message, wparam, lparam); +} + +void Win32Window::Destroy() { + OnDestroy(); + + if (window_handle_) { + DestroyWindow(window_handle_); + window_handle_ = nullptr; + } + if (g_active_window_count == 0) { + WindowClassRegistrar::GetInstance()->UnregisterWindowClass(); + } +} + +Win32Window* Win32Window::GetThisFromHandle(HWND const window) noexcept { + return reinterpret_cast( + GetWindowLongPtr(window, GWLP_USERDATA)); +} + +void Win32Window::SetChildContent(HWND content) { + child_content_ = content; + SetParent(content, window_handle_); + RECT frame = GetClientArea(); + + MoveWindow(content, frame.left, frame.top, frame.right - frame.left, + frame.bottom - frame.top, true); + + SetFocus(child_content_); +} + +RECT Win32Window::GetClientArea() { + RECT frame; + GetClientRect(window_handle_, &frame); + return frame; +} + +HWND Win32Window::GetHandle() { + return window_handle_; +} + +void Win32Window::SetQuitOnClose(bool quit_on_close) { + quit_on_close_ = quit_on_close; +} + +bool Win32Window::OnCreate() { + // No-op; provided for subclasses. + return true; +} + +void Win32Window::OnDestroy() { + // No-op; provided for subclasses. +} + +void Win32Window::UpdateTheme(HWND const window) { + DWORD light_mode; + DWORD light_mode_size = sizeof(light_mode); + LSTATUS result = RegGetValue(HKEY_CURRENT_USER, kGetPreferredBrightnessRegKey, + kGetPreferredBrightnessRegValue, + RRF_RT_REG_DWORD, nullptr, &light_mode, + &light_mode_size); + + if (result == ERROR_SUCCESS) { + BOOL enable_dark_mode = light_mode == 0; + DwmSetWindowAttribute(window, DWMWA_USE_IMMERSIVE_DARK_MODE, + &enable_dark_mode, sizeof(enable_dark_mode)); + } +} diff --git a/dynamic_theme/windows/runner/win32_window.h b/dynamic_theme/windows/runner/win32_window.h new file mode 100644 index 00000000000..e901dde684e --- /dev/null +++ b/dynamic_theme/windows/runner/win32_window.h @@ -0,0 +1,102 @@ +#ifndef RUNNER_WIN32_WINDOW_H_ +#define RUNNER_WIN32_WINDOW_H_ + +#include + +#include +#include +#include + +// A class abstraction for a high DPI-aware Win32 Window. Intended to be +// inherited from by classes that wish to specialize with custom +// rendering and input handling +class Win32Window { + public: + struct Point { + unsigned int x; + unsigned int y; + Point(unsigned int x, unsigned int y) : x(x), y(y) {} + }; + + struct Size { + unsigned int width; + unsigned int height; + Size(unsigned int width, unsigned int height) + : width(width), height(height) {} + }; + + Win32Window(); + virtual ~Win32Window(); + + // Creates a win32 window with |title| that is positioned and sized using + // |origin| and |size|. New windows are created on the default monitor. Window + // sizes are specified to the OS in physical pixels, hence to ensure a + // consistent size this function will scale the inputted width and height as + // as appropriate for the default monitor. The window is invisible until + // |Show| is called. Returns true if the window was created successfully. + bool Create(const std::wstring& title, const Point& origin, const Size& size); + + // Show the current window. Returns true if the window was successfully shown. + bool Show(); + + // Release OS resources associated with window. + void Destroy(); + + // Inserts |content| into the window tree. + void SetChildContent(HWND content); + + // Returns the backing Window handle to enable clients to set icon and other + // window properties. Returns nullptr if the window has been destroyed. + HWND GetHandle(); + + // If true, closing this window will quit the application. + void SetQuitOnClose(bool quit_on_close); + + // Return a RECT representing the bounds of the current client area. + RECT GetClientArea(); + + protected: + // Processes and route salient window messages for mouse handling, + // size change and DPI. Delegates handling of these to member overloads that + // inheriting classes can handle. + virtual LRESULT MessageHandler(HWND window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept; + + // Called when CreateAndShow is called, allowing subclass window-related + // setup. Subclasses should return false if setup fails. + virtual bool OnCreate(); + + // Called when Destroy is called. + virtual void OnDestroy(); + + private: + friend class WindowClassRegistrar; + + // OS callback called by message pump. Handles the WM_NCCREATE message which + // is passed when the non-client area is being created and enables automatic + // non-client DPI scaling so that the non-client area automatically + // responds to changes in DPI. All other messages are handled by + // MessageHandler. + static LRESULT CALLBACK WndProc(HWND const window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept; + + // Retrieves a class instance pointer for |window| + static Win32Window* GetThisFromHandle(HWND const window) noexcept; + + // Update the window frame's theme to match the system theme. + static void UpdateTheme(HWND const window); + + bool quit_on_close_ = false; + + // window handle for top level window. + HWND window_handle_ = nullptr; + + // window handle for hosted content. + HWND child_content_ = nullptr; +}; + +#endif // RUNNER_WIN32_WINDOW_H_ diff --git a/experimental/pedometer/example/pubspec.yaml b/experimental/pedometer/example/pubspec.yaml index 742e4a7b4ab..fca5206a486 100644 --- a/experimental/pedometer/example/pubspec.yaml +++ b/experimental/pedometer/example/pubspec.yaml @@ -41,8 +41,8 @@ dependencies: ffi: ^2.1.2 intl: ^0.19.0 - jni: ^0.8.0 - fl_chart: ^0.67.0 + jni: ^0.9.0 + fl_chart: ^0.68.0 dev_dependencies: flutter_test: @@ -53,7 +53,7 @@ dev_dependencies: # activated in the `analysis_options.yaml` file located at the root of your # package. See that file for information about deactivating specific lint # rules and activating additional ones. - flutter_lints: ^3.0.0 + flutter_lints: ^4.0.0 # For information on the generic Dart part of this file, see the # following page: https://dart.dev/tools/pub/pubspec diff --git a/experimental/pedometer/lib/health_connect.dart b/experimental/pedometer/lib/health_connect.dart index 79fc483a53a..718376d50b5 100644 --- a/experimental/pedometer/lib/health_connect.dart +++ b/experimental/pedometer/lib/health_connect.dart @@ -16,75 +16,94 @@ // ignore_for_file: unused_import // ignore_for_file: unused_local_variable // ignore_for_file: unused_shown_name +// ignore_for_file: use_super_parameters import "dart:isolate" show ReceivePort; import "dart:ffi" as ffi; import "package:jni/internal_helpers_for_jnigen.dart"; import "package:jni/jni.dart" as jni; -// Auto-generated initialization code. - -final ffi.Pointer Function(String sym) jniLookup = - ProtectedJniExtensions.initGeneratedLibrary("health_connect"); - /// from: androidx.health.connect.client.HealthConnectClient$Companion class HealthConnectClient_Companion extends jni.JObject { @override late final jni.JObjType $type = type; HealthConnectClient_Companion.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/HealthConnectClient$Companion"); /// The type which includes information such as the signature of this class. static const type = $HealthConnectClient_CompanionType(); - static final _get_DEFAULT_PROVIDER_PACKAGE_NAME = jniLookup< - ffi.NativeFunction>( - "get_HealthConnectClient_Companion__DEFAULT_PROVIDER_PACKAGE_NAME") - .asFunction(); + static final _id_DEFAULT_PROVIDER_PACKAGE_NAME = _class.staticFieldId( + r"DEFAULT_PROVIDER_PACKAGE_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String DEFAULT_PROVIDER_PACKAGE_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get DEFAULT_PROVIDER_PACKAGE_NAME => - _get_DEFAULT_PROVIDER_PACKAGE_NAME().object(const jni.JStringType()); + _id_DEFAULT_PROVIDER_PACKAGE_NAME.get(_class, const jni.JStringType()); - static final _get_HEALTH_CONNECT_CLIENT_TAG = - jniLookup>( - "get_HealthConnectClient_Companion__HEALTH_CONNECT_CLIENT_TAG") - .asFunction(); + static final _id_HEALTH_CONNECT_CLIENT_TAG = _class.staticFieldId( + r"HEALTH_CONNECT_CLIENT_TAG", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String HEALTH_CONNECT_CLIENT_TAG /// The returned object must be released after use, by calling the [release] method. static jni.JString get HEALTH_CONNECT_CLIENT_TAG => - _get_HEALTH_CONNECT_CLIENT_TAG().object(const jni.JStringType()); + _id_HEALTH_CONNECT_CLIENT_TAG.get(_class, const jni.JStringType()); - static final _isAvailable = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "HealthConnectClient_Companion__isAvailable") + static final _id_isAvailable = _class.instanceMethodId( + r"isAvailable", + r"(Landroid/content/Context;Ljava/util/List;)Z", + ); + + static final _isAvailable = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public final boolean isAvailable(android.content.Context context, java.util.List list) bool isAvailable( Context context, jni.JList list, ) { - return _isAvailable(reference.pointer, context.reference.pointer, - list.reference.pointer) + return _isAvailable(reference.pointer, _id_isAvailable as jni.JMethodIDPtr, + context.reference.pointer, list.reference.pointer) .boolean; } - static final _getOrCreate = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "HealthConnectClient_Companion__getOrCreate") + static final _id_getOrCreate = _class.instanceMethodId( + r"getOrCreate", + r"(Landroid/content/Context;Ljava/util/List;)Landroidx/health/connect/client/HealthConnectClient;", + ); + + static final _getOrCreate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public final androidx.health.connect.client.HealthConnectClient getOrCreate(android.content.Context context, java.util.List list) /// The returned object must be released after use, by calling the [release] method. @@ -92,42 +111,59 @@ class HealthConnectClient_Companion extends jni.JObject { Context context, jni.JList list, ) { - return _getOrCreate(reference.pointer, context.reference.pointer, - list.reference.pointer) + return _getOrCreate(reference.pointer, _id_getOrCreate as jni.JMethodIDPtr, + context.reference.pointer, list.reference.pointer) .object(const $HealthConnectClientType()); } - static final _isAvailable1 = jniLookup< + static final _id_isAvailable1 = _class.instanceMethodId( + r"isAvailable", + r"(Landroid/content/Context;)Z", + ); + + static final _isAvailable1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "HealthConnectClient_Companion__isAvailable1") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final boolean isAvailable(android.content.Context context) bool isAvailable1( Context context, ) { - return _isAvailable1(reference.pointer, context.reference.pointer).boolean; + return _isAvailable1(reference.pointer, + _id_isAvailable1 as jni.JMethodIDPtr, context.reference.pointer) + .boolean; } - static final _getOrCreate1 = jniLookup< + static final _id_getOrCreate1 = _class.instanceMethodId( + r"getOrCreate", + r"(Landroid/content/Context;)Landroidx/health/connect/client/HealthConnectClient;", + ); + + static final _getOrCreate1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "HealthConnectClient_Companion__getOrCreate1") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final androidx.health.connect.client.HealthConnectClient getOrCreate(android.content.Context context) /// The returned object must be released after use, by calling the [release] method. HealthConnectClient getOrCreate1( Context context, ) { - return _getOrCreate1(reference.pointer, context.reference.pointer) + return _getOrCreate1(reference.pointer, + _id_getOrCreate1 as jni.JMethodIDPtr, context.reference.pointer) .object(const $HealthConnectClientType()); } } @@ -166,63 +202,87 @@ class HealthConnectClient extends jni.JObject { late final jni.JObjType $type = type; HealthConnectClient.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r"androidx/health/connect/client/HealthConnectClient"); /// The type which includes information such as the signature of this class. static const type = $HealthConnectClientType(); - static final _get_Companion = - jniLookup>( - "get_HealthConnectClient__Companion") - .asFunction(); + static final _id_Companion = _class.staticFieldId( + r"Companion", + r"Landroidx/health/connect/client/HealthConnectClient$Companion;", + ); /// from: static public final androidx.health.connect.client.HealthConnectClient$Companion Companion /// The returned object must be released after use, by calling the [release] method. static HealthConnectClient_Companion get Companion => - _get_Companion().object(const $HealthConnectClient_CompanionType()); + _id_Companion.get(_class, const $HealthConnectClient_CompanionType()); - static final _get_DEFAULT_PROVIDER_PACKAGE_NAME = - jniLookup>( - "get_HealthConnectClient__DEFAULT_PROVIDER_PACKAGE_NAME") - .asFunction(); + static final _id_DEFAULT_PROVIDER_PACKAGE_NAME = _class.staticFieldId( + r"DEFAULT_PROVIDER_PACKAGE_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String DEFAULT_PROVIDER_PACKAGE_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get DEFAULT_PROVIDER_PACKAGE_NAME => - _get_DEFAULT_PROVIDER_PACKAGE_NAME().object(const jni.JStringType()); + _id_DEFAULT_PROVIDER_PACKAGE_NAME.get(_class, const jni.JStringType()); - static final _get_HEALTH_CONNECT_CLIENT_TAG = - jniLookup>( - "get_HealthConnectClient__HEALTH_CONNECT_CLIENT_TAG") - .asFunction(); + static final _id_HEALTH_CONNECT_CLIENT_TAG = _class.staticFieldId( + r"HEALTH_CONNECT_CLIENT_TAG", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String HEALTH_CONNECT_CLIENT_TAG /// The returned object must be released after use, by calling the [release] method. static jni.JString get HEALTH_CONNECT_CLIENT_TAG => - _get_HEALTH_CONNECT_CLIENT_TAG().object(const jni.JStringType()); + _id_HEALTH_CONNECT_CLIENT_TAG.get(_class, const jni.JStringType()); + + static final _id_getPermissionController = _class.instanceMethodId( + r"getPermissionController", + r"()Landroidx/health/connect/client/PermissionController;", + ); - static final _getPermissionController = jniLookup< - ffi - .NativeFunction)>>( - "HealthConnectClient__getPermissionController") - .asFunction)>(); + static final _getPermissionController = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract androidx.health.connect.client.PermissionController getPermissionController() /// The returned object must be released after use, by calling the [release] method. PermissionController getPermissionController() { - return _getPermissionController(reference.pointer) + return _getPermissionController( + reference.pointer, _id_getPermissionController as jni.JMethodIDPtr) .object(const $PermissionControllerType()); } - static final _insertRecords = jniLookup< + static final _id_insertRecords = _class.instanceMethodId( + r"insertRecords", + r"(Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _insertRecords = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__insertRecords") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object insertRecords(java.util.List list, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -232,8 +292,8 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _insertRecords( - reference.pointer, list.reference.pointer, $c.reference.pointer) + _insertRecords(reference.pointer, _id_insertRecords as jni.JMethodIDPtr, + list.reference.pointer, $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -243,15 +303,24 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _updateRecords = jniLookup< + static final _id_updateRecords = _class.instanceMethodId( + r"updateRecords", + r"(Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _updateRecords = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__updateRecords") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object updateRecords(java.util.List list, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -261,8 +330,8 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _updateRecords( - reference.pointer, list.reference.pointer, $c.reference.pointer) + _updateRecords(reference.pointer, _id_updateRecords as jni.JMethodIDPtr, + list.reference.pointer, $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -272,17 +341,27 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _deleteRecords = jniLookup< + static final _id_deleteRecords = _class.instanceMethodId( + r"deleteRecords", + r"(Lkotlin/reflect/KClass;Ljava/util/List;Ljava/util/List;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _deleteRecords = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__deleteRecords") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< jni.JniResult Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -300,6 +379,7 @@ class HealthConnectClient extends jni.JObject { ProtectedJniExtensions.newPortContinuation($p)); _deleteRecords( reference.pointer, + _id_deleteRecords as jni.JMethodIDPtr, kClass.reference.pointer, list.reference.pointer, list1.reference.pointer, @@ -313,17 +393,29 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _deleteRecords1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>( - "HealthConnectClient__deleteRecords1") + static final _id_deleteRecords1 = _class.instanceMethodId( + r"deleteRecords", + r"(Lkotlin/reflect/KClass;Landroidx/health/connect/client/time/TimeRangeFilter;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _deleteRecords1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public abstract java.lang.Object deleteRecords(kotlin.reflect.KClass kClass, androidx.health.connect.client.time.TimeRangeFilter timeRangeFilter, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -334,8 +426,12 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _deleteRecords1(reference.pointer, kClass.reference.pointer, - timeRangeFilter.reference.pointer, $c.reference.pointer) + _deleteRecords1( + reference.pointer, + _id_deleteRecords1 as jni.JMethodIDPtr, + kClass.reference.pointer, + timeRangeFilter.reference.pointer, + $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -345,16 +441,29 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _readRecord = jniLookup< + static final _id_readRecord = _class.instanceMethodId( + r"readRecord", + r"(Lkotlin/reflect/KClass;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _readRecord = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__readRecord") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public abstract java.lang.Object readRecord(kotlin.reflect.KClass kClass, java.lang.String string, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -366,8 +475,12 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _readRecord(reference.pointer, kClass.reference.pointer, - string.reference.pointer, $c.reference.pointer) + _readRecord( + reference.pointer, + _id_readRecord as jni.JMethodIDPtr, + kClass.reference.pointer, + string.reference.pointer, + $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -377,15 +490,24 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _readRecords = jniLookup< + static final _id_readRecords = _class.instanceMethodId( + r"readRecords", + r"(Landroidx/health/connect/client/request/ReadRecordsRequest;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _readRecords = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__readRecords") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object readRecords(androidx.health.connect.client.request.ReadRecordsRequest readRecordsRequest, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -399,8 +521,8 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _readRecords(reference.pointer, readRecordsRequest.reference.pointer, - $c.reference.pointer) + _readRecords(reference.pointer, _id_readRecords as jni.JMethodIDPtr, + readRecordsRequest.reference.pointer, $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -410,15 +532,24 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _aggregate = jniLookup< + static final _id_aggregate = _class.instanceMethodId( + r"aggregate", + r"(Landroidx/health/connect/client/request/AggregateRequest;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _aggregate = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__aggregate") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object aggregate(androidx.health.connect.client.request.AggregateRequest aggregateRequest, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -428,8 +559,8 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _aggregate(reference.pointer, aggregateRequest.reference.pointer, - $c.reference.pointer) + _aggregate(reference.pointer, _id_aggregate as jni.JMethodIDPtr, + aggregateRequest.reference.pointer, $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const $AggregationResultType().jClass.reference.pointer; @@ -439,14 +570,24 @@ class HealthConnectClient extends jni.JObject { return const $AggregationResultType().fromReference($o); } - static final _aggregateGroupByDuration = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "HealthConnectClient__aggregateGroupByDuration") + static final _id_aggregateGroupByDuration = _class.instanceMethodId( + r"aggregateGroupByDuration", + r"(Landroidx/health/connect/client/request/AggregateGroupByDurationRequest;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _aggregateGroupByDuration = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object aggregateGroupByDuration(androidx.health.connect.client.request.AggregateGroupByDurationRequest aggregateGroupByDurationRequest, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -458,6 +599,7 @@ class HealthConnectClient extends jni.JObject { ProtectedJniExtensions.newPortContinuation($p)); _aggregateGroupByDuration( reference.pointer, + _id_aggregateGroupByDuration as jni.JMethodIDPtr, aggregateGroupByDurationRequest.reference.pointer, $c.reference.pointer) .object(const jni.JObjectType()); @@ -469,14 +611,24 @@ class HealthConnectClient extends jni.JObject { return const jni.JListType(jni.JObjectType()).fromReference($o); } - static final _aggregateGroupByPeriod = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "HealthConnectClient__aggregateGroupByPeriod") + static final _id_aggregateGroupByPeriod = _class.instanceMethodId( + r"aggregateGroupByPeriod", + r"(Landroidx/health/connect/client/request/AggregateGroupByPeriodRequest;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _aggregateGroupByPeriod = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object aggregateGroupByPeriod(androidx.health.connect.client.request.AggregateGroupByPeriodRequest aggregateGroupByPeriodRequest, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -488,6 +640,7 @@ class HealthConnectClient extends jni.JObject { ProtectedJniExtensions.newPortContinuation($p)); _aggregateGroupByPeriod( reference.pointer, + _id_aggregateGroupByPeriod as jni.JMethodIDPtr, aggregateGroupByPeriodRequest.reference.pointer, $c.reference.pointer) .object(const jni.JObjectType()); @@ -499,14 +652,24 @@ class HealthConnectClient extends jni.JObject { return const jni.JListType(jni.JObjectType()).fromReference($o); } - static final _getChangesToken = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "HealthConnectClient__getChangesToken") + static final _id_getChangesToken = _class.instanceMethodId( + r"getChangesToken", + r"(Landroidx/health/connect/client/request/ChangesTokenRequest;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _getChangesToken = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object getChangesToken(androidx.health.connect.client.request.ChangesTokenRequest changesTokenRequest, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -516,8 +679,8 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _getChangesToken(reference.pointer, changesTokenRequest.reference.pointer, - $c.reference.pointer) + _getChangesToken(reference.pointer, _id_getChangesToken as jni.JMethodIDPtr, + changesTokenRequest.reference.pointer, $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JStringType().jClass.reference.pointer; @@ -527,17 +690,29 @@ class HealthConnectClient extends jni.JObject { return const jni.JStringType().fromReference($o); } - static final _registerForDataNotifications = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>( - "HealthConnectClient__registerForDataNotifications") + static final _id_registerForDataNotifications = _class.instanceMethodId( + r"registerForDataNotifications", + r"(Ljava/lang/String;Ljava/lang/Iterable;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _registerForDataNotifications = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public abstract java.lang.Object registerForDataNotifications(java.lang.String string, java.lang.Iterable iterable, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -548,8 +723,12 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _registerForDataNotifications(reference.pointer, string.reference.pointer, - iterable.reference.pointer, $c.reference.pointer) + _registerForDataNotifications( + reference.pointer, + _id_registerForDataNotifications as jni.JMethodIDPtr, + string.reference.pointer, + iterable.reference.pointer, + $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -559,14 +738,24 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _unregisterFromDataNotifications = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "HealthConnectClient__unregisterFromDataNotifications") + static final _id_unregisterFromDataNotifications = _class.instanceMethodId( + r"unregisterFromDataNotifications", + r"(Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _unregisterFromDataNotifications = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object unregisterFromDataNotifications(java.lang.String string, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -577,7 +766,10 @@ class HealthConnectClient extends jni.JObject { final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); _unregisterFromDataNotifications( - reference.pointer, string.reference.pointer, $c.reference.pointer) + reference.pointer, + _id_unregisterFromDataNotifications as jni.JMethodIDPtr, + string.reference.pointer, + $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -587,15 +779,24 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _getChanges = jniLookup< + static final _id_getChanges = _class.instanceMethodId( + r"getChanges", + r"(Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _getChanges = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__getChanges") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object getChanges(java.lang.String string, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -605,8 +806,8 @@ class HealthConnectClient extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _getChanges( - reference.pointer, string.reference.pointer, $c.reference.pointer) + _getChanges(reference.pointer, _id_getChanges as jni.JMethodIDPtr, + string.reference.pointer, $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -616,12 +817,23 @@ class HealthConnectClient extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _isAvailable = jniLookup< + static final _id_isAvailable = _class.staticMethodId( + r"isAvailable", + r"(Landroid/content/Context;Ljava/util/List;)Z", + ); + + static final _isAvailable = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__isAvailable") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallStaticBooleanMethod") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: static public boolean isAvailable(android.content.Context context, java.util.List list) @@ -629,16 +841,31 @@ class HealthConnectClient extends jni.JObject { Context context, jni.JList list, ) { - return _isAvailable(context.reference.pointer, list.reference.pointer) + return _isAvailable( + _class.reference.pointer, + _id_isAvailable as jni.JMethodIDPtr, + context.reference.pointer, + list.reference.pointer) .boolean; } - static final _getOrCreate = jniLookup< + static final _id_getOrCreate = _class.staticMethodId( + r"getOrCreate", + r"(Landroid/content/Context;Ljava/util/List;)Landroidx/health/connect/client/HealthConnectClient;", + ); + + static final _getOrCreate = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("HealthConnectClient__getOrCreate") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallStaticObjectMethod") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: static public androidx.health.connect.client.HealthConnectClient getOrCreate(android.content.Context context, java.util.List list) @@ -647,35 +874,62 @@ class HealthConnectClient extends jni.JObject { Context context, jni.JList list, ) { - return _getOrCreate(context.reference.pointer, list.reference.pointer) + return _getOrCreate( + _class.reference.pointer, + _id_getOrCreate as jni.JMethodIDPtr, + context.reference.pointer, + list.reference.pointer) .object(const $HealthConnectClientType()); } - static final _isAvailable1 = jniLookup< - ffi - .NativeFunction)>>( - "HealthConnectClient__isAvailable1") - .asFunction)>(); + static final _id_isAvailable1 = _class.staticMethodId( + r"isAvailable", + r"(Landroid/content/Context;)Z", + ); + + static final _isAvailable1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticBooleanMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public boolean isAvailable(android.content.Context context) static bool isAvailable1( Context context, ) { - return _isAvailable1(context.reference.pointer).boolean; + return _isAvailable1(_class.reference.pointer, + _id_isAvailable1 as jni.JMethodIDPtr, context.reference.pointer) + .boolean; } - static final _getOrCreate1 = jniLookup< - ffi - .NativeFunction)>>( - "HealthConnectClient__getOrCreate1") - .asFunction)>(); + static final _id_getOrCreate1 = _class.staticMethodId( + r"getOrCreate", + r"(Landroid/content/Context;)Landroidx/health/connect/client/HealthConnectClient;", + ); + + static final _getOrCreate1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public androidx.health.connect.client.HealthConnectClient getOrCreate(android.content.Context context) /// The returned object must be released after use, by calling the [release] method. static HealthConnectClient getOrCreate1( Context context, ) { - return _getOrCreate1(context.reference.pointer) + return _getOrCreate1(_class.reference.pointer, + _id_getOrCreate1 as jni.JMethodIDPtr, context.reference.pointer) .object(const $HealthConnectClientType()); } } @@ -713,19 +967,31 @@ class PermissionController_Companion extends jni.JObject { late final jni.JObjType $type = type; PermissionController_Companion.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/PermissionController$Companion"); /// The type which includes information such as the signature of this class. static const type = $PermissionController_CompanionType(); - static final _createRequestPermissionResultContract = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "PermissionController_Companion__createRequestPermissionResultContract") - .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + static final _id_createRequestPermissionResultContract = + _class.instanceMethodId( + r"createRequestPermissionResultContract", + r"(Ljava/lang/String;)Landroidx/activity/result/contract/ActivityResultContract;", + ); + + static final _createRequestPermissionResultContract = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final androidx.activity.result.contract.ActivityResultContract createRequestPermissionResultContract(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -733,20 +999,36 @@ class PermissionController_Companion extends jni.JObject { jni.JString string, ) { return _createRequestPermissionResultContract( - reference.pointer, string.reference.pointer) + reference.pointer, + _id_createRequestPermissionResultContract as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _createRequestPermissionResultContract1 = jniLookup< - ffi - .NativeFunction)>>( - "PermissionController_Companion__createRequestPermissionResultContract1") - .asFunction)>(); + static final _id_createRequestPermissionResultContract1 = + _class.instanceMethodId( + r"createRequestPermissionResultContract", + r"()Landroidx/activity/result/contract/ActivityResultContract;", + ); + + static final _createRequestPermissionResultContract1 = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final androidx.activity.result.contract.ActivityResultContract createRequestPermissionResultContract() /// The returned object must be released after use, by calling the [release] method. jni.JObject createRequestPermissionResultContract1() { - return _createRequestPermissionResultContract1(reference.pointer) + return _createRequestPermissionResultContract1(reference.pointer, + _id_createRequestPermissionResultContract1 as jni.JMethodIDPtr) .object(const jni.JObjectType()); } } @@ -785,29 +1067,42 @@ class PermissionController extends jni.JObject { late final jni.JObjType $type = type; PermissionController.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/PermissionController"); /// The type which includes information such as the signature of this class. static const type = $PermissionControllerType(); - static final _get_Companion = - jniLookup>( - "get_PermissionController__Companion") - .asFunction(); + static final _id_Companion = _class.staticFieldId( + r"Companion", + r"Landroidx/health/connect/client/PermissionController$Companion;", + ); /// from: static public final androidx.health.connect.client.PermissionController$Companion Companion /// The returned object must be released after use, by calling the [release] method. static PermissionController_Companion get Companion => - _get_Companion().object(const $PermissionController_CompanionType()); + _id_Companion.get(_class, const $PermissionController_CompanionType()); - static final _getGrantedPermissions = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "PermissionController__getGrantedPermissions") + static final _id_getGrantedPermissions = _class.instanceMethodId( + r"getGrantedPermissions", + r"(Ljava/util/Set;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _getGrantedPermissions = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract java.lang.Object getGrantedPermissions(java.util.Set set, kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -818,7 +1113,10 @@ class PermissionController extends jni.JObject { final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); _getGrantedPermissions( - reference.pointer, set0.reference.pointer, $c.reference.pointer) + reference.pointer, + _id_getGrantedPermissions as jni.JMethodIDPtr, + set0.reference.pointer, + $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JSetType(jni.JObjectType()).jClass.reference.pointer; @@ -828,14 +1126,21 @@ class PermissionController extends jni.JObject { return const jni.JSetType(jni.JObjectType()).fromReference($o); } - static final _revokeAllPermissions = jniLookup< + static final _id_revokeAllPermissions = _class.instanceMethodId( + r"revokeAllPermissions", + r"(Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", + ); + + static final _revokeAllPermissions = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "PermissionController__revokeAllPermissions") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract java.lang.Object revokeAllPermissions(kotlin.coroutines.Continuation continuation) /// The returned object must be released after use, by calling the [release] method. @@ -843,7 +1148,8 @@ class PermissionController extends jni.JObject { final $p = ReceivePort(); final $c = jni.JObject.fromReference( ProtectedJniExtensions.newPortContinuation($p)); - _revokeAllPermissions(reference.pointer, $c.reference.pointer) + _revokeAllPermissions(reference.pointer, + _id_revokeAllPermissions as jni.JMethodIDPtr, $c.reference.pointer) .object(const jni.JObjectType()); final $o = jni.JGlobalReference(jni.JObjectPtr.fromAddress(await $p.first)); final $k = const jni.JObjectType().jClass.reference.pointer; @@ -853,30 +1159,60 @@ class PermissionController extends jni.JObject { return const jni.JObjectType().fromReference($o); } - static final _createRequestPermissionResultContract = jniLookup< - ffi - .NativeFunction)>>( - "PermissionController__createRequestPermissionResultContract") - .asFunction)>(); + static final _id_createRequestPermissionResultContract = + _class.staticMethodId( + r"createRequestPermissionResultContract", + r"(Ljava/lang/String;)Landroidx/activity/result/contract/ActivityResultContract;", + ); + + static final _createRequestPermissionResultContract = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public androidx.activity.result.contract.ActivityResultContract createRequestPermissionResultContract(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. static jni.JObject createRequestPermissionResultContract( jni.JString string, ) { - return _createRequestPermissionResultContract(string.reference.pointer) + return _createRequestPermissionResultContract( + _class.reference.pointer, + _id_createRequestPermissionResultContract as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _createRequestPermissionResultContract1 = - jniLookup>( - "PermissionController__createRequestPermissionResultContract1") - .asFunction(); + static final _id_createRequestPermissionResultContract1 = + _class.staticMethodId( + r"createRequestPermissionResultContract", + r"()Landroidx/activity/result/contract/ActivityResultContract;", + ); - /// from: static public androidx.activity.result.contract.ActivityResultContract createRequestPermissionResultContract() + static final _createRequestPermissionResultContract1 = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: static public androidx.activity.result.contract.ActivityResultContract createRequestPermissionResultContract() /// The returned object must be released after use, by calling the [release] method. static jni.JObject createRequestPermissionResultContract1() { - return _createRequestPermissionResultContract1() + return _createRequestPermissionResultContract1(_class.reference.pointer, + _id_createRequestPermissionResultContract1 as jni.JMethodIDPtr) .object(const jni.JObjectType()); } } @@ -915,24 +1251,39 @@ class StepsRecord_Companion extends jni.JObject { late final jni.JObjType $type = type; StepsRecord_Companion.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/records/StepsRecord$Companion"); /// The type which includes information such as the signature of this class. static const type = $StepsRecord_CompanionType(); - static final _new0 = jniLookup< - ffi - .NativeFunction)>>( - "StepsRecord_Companion__new0") - .asFunction)>(); + static final _id_new0 = _class.constructorId( + r"(Lkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_NewObject") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void (kotlin.jvm.internal.DefaultConstructorMarker defaultConstructorMarker) /// The returned object must be released after use, by calling the [release] method. factory StepsRecord_Companion( jni.JObject defaultConstructorMarker, ) { - return StepsRecord_Companion.fromReference( - _new0(defaultConstructorMarker.reference.pointer).reference); + return StepsRecord_Companion.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + defaultConstructorMarker.reference.pointer) + .reference); } } @@ -970,42 +1321,56 @@ class StepsRecord extends jni.JObject { late final jni.JObjType $type = type; StepsRecord.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r"androidx/health/connect/client/records/StepsRecord"); /// The type which includes information such as the signature of this class. static const type = $StepsRecordType(); - static final _get_Companion = - jniLookup>( - "get_StepsRecord__Companion") - .asFunction(); + static final _id_Companion = _class.staticFieldId( + r"Companion", + r"Landroidx/health/connect/client/records/StepsRecord$Companion;", + ); /// from: static public final androidx.health.connect.client.records.StepsRecord$Companion Companion /// The returned object must be released after use, by calling the [release] method. static StepsRecord_Companion get Companion => - _get_Companion().object(const $StepsRecord_CompanionType()); + _id_Companion.get(_class, const $StepsRecord_CompanionType()); - static final _get_COUNT_TOTAL = - jniLookup>( - "get_StepsRecord__COUNT_TOTAL") - .asFunction(); + static final _id_COUNT_TOTAL = _class.staticFieldId( + r"COUNT_TOTAL", + r"Landroidx/health/connect/client/aggregate/AggregateMetric;", + ); /// from: static public final androidx.health.connect.client.aggregate.AggregateMetric COUNT_TOTAL /// The returned object must be released after use, by calling the [release] method. static AggregateMetric get COUNT_TOTAL => - _get_COUNT_TOTAL().object(const $AggregateMetricType(jni.JLongType())); + _id_COUNT_TOTAL.get(_class, const $AggregateMetricType(jni.JLongType())); + + static final _id_new0 = _class.constructorId( + r"(JLjava/time/Instant;Ljava/time/ZoneOffset;Ljava/time/Instant;Ljava/time/ZoneOffset;Landroidx/health/connect/client/records/metadata/Metadata;)V", + ); - static final _new0 = jniLookup< + static final _new0 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Int64, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, ffi.Pointer, - ffi.Pointer)>>("StepsRecord__new0") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, int, ffi.Pointer, ffi.Pointer, @@ -1024,6 +1389,8 @@ class StepsRecord extends jni.JObject { jni.JObject metadata, ) { return StepsRecord.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, j, instant.reference.pointer, zoneOffset.reference.pointer, @@ -1033,19 +1400,30 @@ class StepsRecord extends jni.JObject { .reference); } - static final _new1 = jniLookup< + static final _id_new1 = _class.constructorId( + r"(JLjava/time/Instant;Ljava/time/ZoneOffset;Ljava/time/Instant;Ljava/time/ZoneOffset;Landroidx/health/connect/client/records/metadata/Metadata;ILkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Int64, - ffi.Pointer, ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("StepsRecord__new1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, int, ffi.Pointer, ffi.Pointer, @@ -1068,6 +1446,8 @@ class StepsRecord extends jni.JObject { jni.JObject defaultConstructorMarker, ) { return StepsRecord.fromReference(_new1( + _class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, j, instant.reference.pointer, zoneOffset.reference.pointer, @@ -1079,102 +1459,197 @@ class StepsRecord extends jni.JObject { .reference); } - static final _getCount = jniLookup< - ffi - .NativeFunction)>>( - "StepsRecord__getCount") - .asFunction)>(); + static final _id_getCount = _class.instanceMethodId( + r"getCount", + r"()J", + ); + + static final _getCount = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallLongMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final long getCount() int getCount() { - return _getCount(reference.pointer).long; + return _getCount(reference.pointer, _id_getCount as jni.JMethodIDPtr).long; } - static final _getStartTime = jniLookup< - ffi - .NativeFunction)>>( - "StepsRecord__getStartTime") - .asFunction)>(); + static final _id_getStartTime = _class.instanceMethodId( + r"getStartTime", + r"()Ljava/time/Instant;", + ); + + static final _getStartTime = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.time.Instant getStartTime() /// The returned object must be released after use, by calling the [release] method. Instant getStartTime() { - return _getStartTime(reference.pointer).object(const $InstantType()); + return _getStartTime( + reference.pointer, _id_getStartTime as jni.JMethodIDPtr) + .object(const $InstantType()); } - static final _getStartZoneOffset = jniLookup< - ffi - .NativeFunction)>>( - "StepsRecord__getStartZoneOffset") - .asFunction)>(); + static final _id_getStartZoneOffset = _class.instanceMethodId( + r"getStartZoneOffset", + r"()Ljava/time/ZoneOffset;", + ); + + static final _getStartZoneOffset = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.time.ZoneOffset getStartZoneOffset() /// The returned object must be released after use, by calling the [release] method. jni.JObject getStartZoneOffset() { - return _getStartZoneOffset(reference.pointer) + return _getStartZoneOffset( + reference.pointer, _id_getStartZoneOffset as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getEndTime = jniLookup< - ffi - .NativeFunction)>>( - "StepsRecord__getEndTime") - .asFunction)>(); + static final _id_getEndTime = _class.instanceMethodId( + r"getEndTime", + r"()Ljava/time/Instant;", + ); + + static final _getEndTime = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.time.Instant getEndTime() /// The returned object must be released after use, by calling the [release] method. Instant getEndTime() { - return _getEndTime(reference.pointer).object(const $InstantType()); + return _getEndTime(reference.pointer, _id_getEndTime as jni.JMethodIDPtr) + .object(const $InstantType()); } - static final _getEndZoneOffset = jniLookup< - ffi - .NativeFunction)>>( - "StepsRecord__getEndZoneOffset") - .asFunction)>(); + static final _id_getEndZoneOffset = _class.instanceMethodId( + r"getEndZoneOffset", + r"()Ljava/time/ZoneOffset;", + ); + + static final _getEndZoneOffset = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.time.ZoneOffset getEndZoneOffset() /// The returned object must be released after use, by calling the [release] method. jni.JObject getEndZoneOffset() { - return _getEndZoneOffset(reference.pointer).object(const jni.JObjectType()); + return _getEndZoneOffset( + reference.pointer, _id_getEndZoneOffset as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getMetadata = jniLookup< - ffi - .NativeFunction)>>( - "StepsRecord__getMetadata") - .asFunction)>(); + static final _id_getMetadata = _class.instanceMethodId( + r"getMetadata", + r"()Landroidx/health/connect/client/records/metadata/Metadata;", + ); + + static final _getMetadata = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public androidx.health.connect.client.records.metadata.Metadata getMetadata() /// The returned object must be released after use, by calling the [release] method. jni.JObject getMetadata() { - return _getMetadata(reference.pointer).object(const jni.JObjectType()); + return _getMetadata(reference.pointer, _id_getMetadata as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _equals = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("StepsRecord__equals") + static final _id_equals = _class.instanceMethodId( + r"equals", + r"(Ljava/lang/Object;)Z", + ); + + static final _equals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean equals(java.lang.Object object) bool equals( jni.JObject object, ) { - return _equals(reference.pointer, object.reference.pointer).boolean; + return _equals(reference.pointer, _id_equals as jni.JMethodIDPtr, + object.reference.pointer) + .boolean; } - static final _hashCode1 = jniLookup< - ffi - .NativeFunction)>>( - "StepsRecord__hashCode1") - .asFunction)>(); + static final _id_hashCode1 = _class.instanceMethodId( + r"hashCode", + r"()I", + ); + + static final _hashCode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int hashCode() int hashCode1() { - return _hashCode1(reference.pointer).integer; + return _hashCode1(reference.pointer, _id_hashCode1 as jni.JMethodIDPtr) + .integer; } } @@ -1210,20 +1685,32 @@ class TimeRangeFilter_Companion extends jni.JObject { late final jni.JObjType $type = type; TimeRangeFilter_Companion.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/time/TimeRangeFilter$Companion"); /// The type which includes information such as the signature of this class. static const type = $TimeRangeFilter_CompanionType(); - static final _between = jniLookup< + static final _id_between = _class.instanceMethodId( + r"between", + r"(Ljava/time/Instant;Ljava/time/Instant;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _between = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter_Companion__between") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public final androidx.health.connect.client.time.TimeRangeFilter between(java.time.Instant instant, java.time.Instant instant1) /// The returned object must be released after use, by calling the [release] method. @@ -1231,19 +1718,29 @@ class TimeRangeFilter_Companion extends jni.JObject { Instant instant, Instant instant1, ) { - return _between(reference.pointer, instant.reference.pointer, - instant1.reference.pointer) + return _between(reference.pointer, _id_between as jni.JMethodIDPtr, + instant.reference.pointer, instant1.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _between1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "TimeRangeFilter_Companion__between1") + static final _id_between1 = _class.instanceMethodId( + r"between", + r"(Ljava/time/LocalDateTime;Ljava/time/LocalDateTime;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _between1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public final androidx.health.connect.client.time.TimeRangeFilter between(java.time.LocalDateTime localDateTime, java.time.LocalDateTime localDateTime1) /// The returned object must be released after use, by calling the [release] method. @@ -1251,92 +1748,140 @@ class TimeRangeFilter_Companion extends jni.JObject { jni.JObject localDateTime, jni.JObject localDateTime1, ) { - return _between1(reference.pointer, localDateTime.reference.pointer, - localDateTime1.reference.pointer) + return _between1(reference.pointer, _id_between1 as jni.JMethodIDPtr, + localDateTime.reference.pointer, localDateTime1.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _before = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter_Companion__before") + static final _id_before = _class.instanceMethodId( + r"before", + r"(Ljava/time/Instant;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _before = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final androidx.health.connect.client.time.TimeRangeFilter before(java.time.Instant instant) /// The returned object must be released after use, by calling the [release] method. TimeRangeFilter before( Instant instant, ) { - return _before(reference.pointer, instant.reference.pointer) + return _before(reference.pointer, _id_before as jni.JMethodIDPtr, + instant.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _before1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter_Companion__before1") + static final _id_before1 = _class.instanceMethodId( + r"before", + r"(Ljava/time/LocalDateTime;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _before1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final androidx.health.connect.client.time.TimeRangeFilter before(java.time.LocalDateTime localDateTime) /// The returned object must be released after use, by calling the [release] method. TimeRangeFilter before1( jni.JObject localDateTime, ) { - return _before1(reference.pointer, localDateTime.reference.pointer) + return _before1(reference.pointer, _id_before1 as jni.JMethodIDPtr, + localDateTime.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _after = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter_Companion__after") + static final _id_after = _class.instanceMethodId( + r"after", + r"(Ljava/time/Instant;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _after = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final androidx.health.connect.client.time.TimeRangeFilter after(java.time.Instant instant) /// The returned object must be released after use, by calling the [release] method. TimeRangeFilter after( Instant instant, ) { - return _after(reference.pointer, instant.reference.pointer) + return _after(reference.pointer, _id_after as jni.JMethodIDPtr, + instant.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _after1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter_Companion__after1") + static final _id_after1 = _class.instanceMethodId( + r"after", + r"(Ljava/time/LocalDateTime;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _after1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final androidx.health.connect.client.time.TimeRangeFilter after(java.time.LocalDateTime localDateTime) /// The returned object must be released after use, by calling the [release] method. TimeRangeFilter after1( jni.JObject localDateTime, ) { - return _after1(reference.pointer, localDateTime.reference.pointer) + return _after1(reference.pointer, _id_after1 as jni.JMethodIDPtr, + localDateTime.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _new0 = jniLookup< - ffi - .NativeFunction)>>( - "TimeRangeFilter_Companion__new0") - .asFunction)>(); + static final _id_new0 = _class.constructorId( + r"(Lkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_NewObject") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void (kotlin.jvm.internal.DefaultConstructorMarker defaultConstructorMarker) /// The returned object must be released after use, by calling the [release] method. factory TimeRangeFilter_Companion( jni.JObject defaultConstructorMarker, ) { - return TimeRangeFilter_Companion.fromReference( - _new0(defaultConstructorMarker.reference.pointer).reference); + return TimeRangeFilter_Companion.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + defaultConstructorMarker.reference.pointer) + .reference); } } @@ -1374,31 +1919,48 @@ class TimeRangeFilter extends jni.JObject { late final jni.JObjType $type = type; TimeRangeFilter.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/time/TimeRangeFilter"); /// The type which includes information such as the signature of this class. static const type = $TimeRangeFilterType(); - static final _get_Companion = - jniLookup>( - "get_TimeRangeFilter__Companion") - .asFunction(); + static final _id_Companion = _class.staticFieldId( + r"Companion", + r"Landroidx/health/connect/client/time/TimeRangeFilter$Companion;", + ); /// from: static public final androidx.health.connect.client.time.TimeRangeFilter$Companion Companion /// The returned object must be released after use, by calling the [release] method. static TimeRangeFilter_Companion get Companion => - _get_Companion().object(const $TimeRangeFilter_CompanionType()); + _id_Companion.get(_class, const $TimeRangeFilter_CompanionType()); - static final _new0 = jniLookup< + static final _id_new0 = _class.constructorId( + r"(Ljava/time/Instant;Ljava/time/Instant;Ljava/time/LocalDateTime;Ljava/time/LocalDateTime;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter__new0") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public void (java.time.Instant instant, java.time.Instant instant1, java.time.LocalDateTime localDateTime, java.time.LocalDateTime localDateTime1) /// The returned object must be released after use, by calling the [release] method. @@ -1409,6 +1971,8 @@ class TimeRangeFilter extends jni.JObject { jni.JObject localDateTime1, ) { return TimeRangeFilter.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, instant.reference.pointer, instant1.reference.pointer, localDateTime.reference.pointer, @@ -1416,17 +1980,28 @@ class TimeRangeFilter extends jni.JObject { .reference); } - static final _new1 = jniLookup< + static final _id_new1 = _class.constructorId( + r"(Ljava/time/Instant;Ljava/time/Instant;Ljava/time/LocalDateTime;Ljava/time/LocalDateTime;ILkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("TimeRangeFilter__new1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -1445,6 +2020,8 @@ class TimeRangeFilter extends jni.JObject { jni.JObject defaultConstructorMarker, ) { return TimeRangeFilter.fromReference(_new1( + _class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, instant.reference.pointer, instant1.reference.pointer, localDateTime.reference.pointer, @@ -1454,48 +2031,95 @@ class TimeRangeFilter extends jni.JObject { .reference); } - static final _equals = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter__equals") + static final _id_equals = _class.instanceMethodId( + r"equals", + r"(Ljava/lang/Object;)Z", + ); + + static final _equals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean equals(java.lang.Object object) bool equals( jni.JObject object, ) { - return _equals(reference.pointer, object.reference.pointer).boolean; + return _equals(reference.pointer, _id_equals as jni.JMethodIDPtr, + object.reference.pointer) + .boolean; } - static final _hashCode1 = jniLookup< - ffi - .NativeFunction)>>( - "TimeRangeFilter__hashCode1") - .asFunction)>(); + static final _id_hashCode1 = _class.instanceMethodId( + r"hashCode", + r"()I", + ); + + static final _hashCode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int hashCode() int hashCode1() { - return _hashCode1(reference.pointer).integer; + return _hashCode1(reference.pointer, _id_hashCode1 as jni.JMethodIDPtr) + .integer; } - static final _new2 = jniLookup>( - "TimeRangeFilter__new2") - .asFunction(); + static final _id_new2 = _class.constructorId( + r"()V", + ); + + static final _new2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_NewObject") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void () /// The returned object must be released after use, by calling the [release] method. factory TimeRangeFilter.new2() { - return TimeRangeFilter.fromReference(_new2().reference); + return TimeRangeFilter.fromReference( + _new2(_class.reference.pointer, _id_new2 as jni.JMethodIDPtr) + .reference); } - static final _between = jniLookup< + static final _id_between = _class.staticMethodId( + r"between", + r"(Ljava/time/Instant;Ljava/time/Instant;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _between = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter__between") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallStaticObjectMethod") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: static public final androidx.health.connect.client.time.TimeRangeFilter between(java.time.Instant instant, java.time.Instant instant1) @@ -1504,16 +2128,28 @@ class TimeRangeFilter extends jni.JObject { Instant instant, Instant instant1, ) { - return _between(instant.reference.pointer, instant1.reference.pointer) + return _between(_class.reference.pointer, _id_between as jni.JMethodIDPtr, + instant.reference.pointer, instant1.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _between1 = jniLookup< + static final _id_between1 = _class.staticMethodId( + r"between", + r"(Ljava/time/LocalDateTime;Ljava/time/LocalDateTime;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _between1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("TimeRangeFilter__between1") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallStaticObjectMethod") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: static public final androidx.health.connect.client.time.TimeRangeFilter between(java.time.LocalDateTime localDateTime, java.time.LocalDateTime localDateTime1) @@ -1522,68 +2158,112 @@ class TimeRangeFilter extends jni.JObject { jni.JObject localDateTime, jni.JObject localDateTime1, ) { - return _between1( + return _between1(_class.reference.pointer, _id_between1 as jni.JMethodIDPtr, localDateTime.reference.pointer, localDateTime1.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _before = jniLookup< - ffi - .NativeFunction)>>( - "TimeRangeFilter__before") - .asFunction)>(); + static final _id_before = _class.staticMethodId( + r"before", + r"(Ljava/time/Instant;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _before = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public final androidx.health.connect.client.time.TimeRangeFilter before(java.time.Instant instant) /// The returned object must be released after use, by calling the [release] method. static TimeRangeFilter before( Instant instant, ) { - return _before(instant.reference.pointer) + return _before(_class.reference.pointer, _id_before as jni.JMethodIDPtr, + instant.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _before1 = jniLookup< - ffi - .NativeFunction)>>( - "TimeRangeFilter__before1") - .asFunction)>(); + static final _id_before1 = _class.staticMethodId( + r"before", + r"(Ljava/time/LocalDateTime;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _before1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public final androidx.health.connect.client.time.TimeRangeFilter before(java.time.LocalDateTime localDateTime) /// The returned object must be released after use, by calling the [release] method. static TimeRangeFilter before1( jni.JObject localDateTime, ) { - return _before1(localDateTime.reference.pointer) + return _before1(_class.reference.pointer, _id_before1 as jni.JMethodIDPtr, + localDateTime.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _after = jniLookup< - ffi - .NativeFunction)>>( - "TimeRangeFilter__after") - .asFunction)>(); + static final _id_after = _class.staticMethodId( + r"after", + r"(Ljava/time/Instant;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _after = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public final androidx.health.connect.client.time.TimeRangeFilter after(java.time.Instant instant) /// The returned object must be released after use, by calling the [release] method. static TimeRangeFilter after( Instant instant, ) { - return _after(instant.reference.pointer) + return _after(_class.reference.pointer, _id_after as jni.JMethodIDPtr, + instant.reference.pointer) .object(const $TimeRangeFilterType()); } - static final _after1 = jniLookup< - ffi - .NativeFunction)>>( - "TimeRangeFilter__after1") - .asFunction)>(); + static final _id_after1 = _class.staticMethodId( + r"after", + r"(Ljava/time/LocalDateTime;)Landroidx/health/connect/client/time/TimeRangeFilter;", + ); + + static final _after1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public final androidx.health.connect.client.time.TimeRangeFilter after(java.time.LocalDateTime localDateTime) /// The returned object must be released after use, by calling the [release] method. static TimeRangeFilter after1( jni.JObject localDateTime, ) { - return _after1(localDateTime.reference.pointer) + return _after1(_class.reference.pointer, _id_after1 as jni.JMethodIDPtr, + localDateTime.reference.pointer) .object(const $TimeRangeFilterType()); } } @@ -1621,100 +2301,102 @@ class Context extends jni.JObject { late final jni.JObjType $type = type; Context.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r"android/content/Context"); /// The type which includes information such as the signature of this class. static const type = $ContextType(); - static final _get_ACCESSIBILITY_SERVICE = - jniLookup>( - "get_Context__ACCESSIBILITY_SERVICE") - .asFunction(); + static final _id_ACCESSIBILITY_SERVICE = _class.staticFieldId( + r"ACCESSIBILITY_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACCESSIBILITY_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACCESSIBILITY_SERVICE => - _get_ACCESSIBILITY_SERVICE().object(const jni.JStringType()); + _id_ACCESSIBILITY_SERVICE.get(_class, const jni.JStringType()); - static final _get_ACCOUNT_SERVICE = - jniLookup>( - "get_Context__ACCOUNT_SERVICE") - .asFunction(); + static final _id_ACCOUNT_SERVICE = _class.staticFieldId( + r"ACCOUNT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACCOUNT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACCOUNT_SERVICE => - _get_ACCOUNT_SERVICE().object(const jni.JStringType()); + _id_ACCOUNT_SERVICE.get(_class, const jni.JStringType()); - static final _get_ACTIVITY_SERVICE = - jniLookup>( - "get_Context__ACTIVITY_SERVICE") - .asFunction(); + static final _id_ACTIVITY_SERVICE = _class.staticFieldId( + r"ACTIVITY_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTIVITY_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTIVITY_SERVICE => - _get_ACTIVITY_SERVICE().object(const jni.JStringType()); + _id_ACTIVITY_SERVICE.get(_class, const jni.JStringType()); - static final _get_ALARM_SERVICE = - jniLookup>( - "get_Context__ALARM_SERVICE") - .asFunction(); + static final _id_ALARM_SERVICE = _class.staticFieldId( + r"ALARM_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ALARM_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ALARM_SERVICE => - _get_ALARM_SERVICE().object(const jni.JStringType()); + _id_ALARM_SERVICE.get(_class, const jni.JStringType()); - static final _get_APPWIDGET_SERVICE = - jniLookup>( - "get_Context__APPWIDGET_SERVICE") - .asFunction(); + static final _id_APPWIDGET_SERVICE = _class.staticFieldId( + r"APPWIDGET_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String APPWIDGET_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get APPWIDGET_SERVICE => - _get_APPWIDGET_SERVICE().object(const jni.JStringType()); + _id_APPWIDGET_SERVICE.get(_class, const jni.JStringType()); - static final _get_APP_OPS_SERVICE = - jniLookup>( - "get_Context__APP_OPS_SERVICE") - .asFunction(); + static final _id_APP_OPS_SERVICE = _class.staticFieldId( + r"APP_OPS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String APP_OPS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get APP_OPS_SERVICE => - _get_APP_OPS_SERVICE().object(const jni.JStringType()); + _id_APP_OPS_SERVICE.get(_class, const jni.JStringType()); - static final _get_APP_SEARCH_SERVICE = - jniLookup>( - "get_Context__APP_SEARCH_SERVICE") - .asFunction(); + static final _id_APP_SEARCH_SERVICE = _class.staticFieldId( + r"APP_SEARCH_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String APP_SEARCH_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get APP_SEARCH_SERVICE => - _get_APP_SEARCH_SERVICE().object(const jni.JStringType()); + _id_APP_SEARCH_SERVICE.get(_class, const jni.JStringType()); - static final _get_AUDIO_SERVICE = - jniLookup>( - "get_Context__AUDIO_SERVICE") - .asFunction(); + static final _id_AUDIO_SERVICE = _class.staticFieldId( + r"AUDIO_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String AUDIO_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get AUDIO_SERVICE => - _get_AUDIO_SERVICE().object(const jni.JStringType()); + _id_AUDIO_SERVICE.get(_class, const jni.JStringType()); - static final _get_BATTERY_SERVICE = - jniLookup>( - "get_Context__BATTERY_SERVICE") - .asFunction(); + static final _id_BATTERY_SERVICE = _class.staticFieldId( + r"BATTERY_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String BATTERY_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get BATTERY_SERVICE => - _get_BATTERY_SERVICE().object(const jni.JStringType()); + _id_BATTERY_SERVICE.get(_class, const jni.JStringType()); /// from: static public final int BIND_ABOVE_CLIENT static const BIND_ABOVE_CLIENT = 8; @@ -1748,125 +2430,125 @@ class Context extends jni.JObject { /// from: static public final int BIND_WAIVE_PRIORITY static const BIND_WAIVE_PRIORITY = 32; - static final _get_BIOMETRIC_SERVICE = - jniLookup>( - "get_Context__BIOMETRIC_SERVICE") - .asFunction(); + static final _id_BIOMETRIC_SERVICE = _class.staticFieldId( + r"BIOMETRIC_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String BIOMETRIC_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get BIOMETRIC_SERVICE => - _get_BIOMETRIC_SERVICE().object(const jni.JStringType()); + _id_BIOMETRIC_SERVICE.get(_class, const jni.JStringType()); - static final _get_BLOB_STORE_SERVICE = - jniLookup>( - "get_Context__BLOB_STORE_SERVICE") - .asFunction(); + static final _id_BLOB_STORE_SERVICE = _class.staticFieldId( + r"BLOB_STORE_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String BLOB_STORE_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get BLOB_STORE_SERVICE => - _get_BLOB_STORE_SERVICE().object(const jni.JStringType()); + _id_BLOB_STORE_SERVICE.get(_class, const jni.JStringType()); - static final _get_BLUETOOTH_SERVICE = - jniLookup>( - "get_Context__BLUETOOTH_SERVICE") - .asFunction(); + static final _id_BLUETOOTH_SERVICE = _class.staticFieldId( + r"BLUETOOTH_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String BLUETOOTH_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get BLUETOOTH_SERVICE => - _get_BLUETOOTH_SERVICE().object(const jni.JStringType()); + _id_BLUETOOTH_SERVICE.get(_class, const jni.JStringType()); - static final _get_BUGREPORT_SERVICE = - jniLookup>( - "get_Context__BUGREPORT_SERVICE") - .asFunction(); + static final _id_BUGREPORT_SERVICE = _class.staticFieldId( + r"BUGREPORT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String BUGREPORT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get BUGREPORT_SERVICE => - _get_BUGREPORT_SERVICE().object(const jni.JStringType()); + _id_BUGREPORT_SERVICE.get(_class, const jni.JStringType()); - static final _get_CAMERA_SERVICE = - jniLookup>( - "get_Context__CAMERA_SERVICE") - .asFunction(); + static final _id_CAMERA_SERVICE = _class.staticFieldId( + r"CAMERA_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CAMERA_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CAMERA_SERVICE => - _get_CAMERA_SERVICE().object(const jni.JStringType()); + _id_CAMERA_SERVICE.get(_class, const jni.JStringType()); - static final _get_CAPTIONING_SERVICE = - jniLookup>( - "get_Context__CAPTIONING_SERVICE") - .asFunction(); + static final _id_CAPTIONING_SERVICE = _class.staticFieldId( + r"CAPTIONING_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CAPTIONING_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CAPTIONING_SERVICE => - _get_CAPTIONING_SERVICE().object(const jni.JStringType()); + _id_CAPTIONING_SERVICE.get(_class, const jni.JStringType()); - static final _get_CARRIER_CONFIG_SERVICE = - jniLookup>( - "get_Context__CARRIER_CONFIG_SERVICE") - .asFunction(); + static final _id_CARRIER_CONFIG_SERVICE = _class.staticFieldId( + r"CARRIER_CONFIG_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CARRIER_CONFIG_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CARRIER_CONFIG_SERVICE => - _get_CARRIER_CONFIG_SERVICE().object(const jni.JStringType()); + _id_CARRIER_CONFIG_SERVICE.get(_class, const jni.JStringType()); - static final _get_CLIPBOARD_SERVICE = - jniLookup>( - "get_Context__CLIPBOARD_SERVICE") - .asFunction(); + static final _id_CLIPBOARD_SERVICE = _class.staticFieldId( + r"CLIPBOARD_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CLIPBOARD_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CLIPBOARD_SERVICE => - _get_CLIPBOARD_SERVICE().object(const jni.JStringType()); + _id_CLIPBOARD_SERVICE.get(_class, const jni.JStringType()); - static final _get_COMPANION_DEVICE_SERVICE = - jniLookup>( - "get_Context__COMPANION_DEVICE_SERVICE") - .asFunction(); + static final _id_COMPANION_DEVICE_SERVICE = _class.staticFieldId( + r"COMPANION_DEVICE_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String COMPANION_DEVICE_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get COMPANION_DEVICE_SERVICE => - _get_COMPANION_DEVICE_SERVICE().object(const jni.JStringType()); + _id_COMPANION_DEVICE_SERVICE.get(_class, const jni.JStringType()); - static final _get_CONNECTIVITY_DIAGNOSTICS_SERVICE = - jniLookup>( - "get_Context__CONNECTIVITY_DIAGNOSTICS_SERVICE") - .asFunction(); + static final _id_CONNECTIVITY_DIAGNOSTICS_SERVICE = _class.staticFieldId( + r"CONNECTIVITY_DIAGNOSTICS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CONNECTIVITY_DIAGNOSTICS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CONNECTIVITY_DIAGNOSTICS_SERVICE => - _get_CONNECTIVITY_DIAGNOSTICS_SERVICE().object(const jni.JStringType()); + _id_CONNECTIVITY_DIAGNOSTICS_SERVICE.get(_class, const jni.JStringType()); - static final _get_CONNECTIVITY_SERVICE = - jniLookup>( - "get_Context__CONNECTIVITY_SERVICE") - .asFunction(); + static final _id_CONNECTIVITY_SERVICE = _class.staticFieldId( + r"CONNECTIVITY_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CONNECTIVITY_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CONNECTIVITY_SERVICE => - _get_CONNECTIVITY_SERVICE().object(const jni.JStringType()); + _id_CONNECTIVITY_SERVICE.get(_class, const jni.JStringType()); - static final _get_CONSUMER_IR_SERVICE = - jniLookup>( - "get_Context__CONSUMER_IR_SERVICE") - .asFunction(); + static final _id_CONSUMER_IR_SERVICE = _class.staticFieldId( + r"CONSUMER_IR_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CONSUMER_IR_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CONSUMER_IR_SERVICE => - _get_CONSUMER_IR_SERVICE().object(const jni.JStringType()); + _id_CONSUMER_IR_SERVICE.get(_class, const jni.JStringType()); /// from: static public final int CONTEXT_IGNORE_SECURITY static const CONTEXT_IGNORE_SECURITY = 2; @@ -1876,275 +2558,275 @@ class Context extends jni.JObject { /// from: static public final int CONTEXT_RESTRICTED static const CONTEXT_RESTRICTED = 4; - static final _get_CROSS_PROFILE_APPS_SERVICE = - jniLookup>( - "get_Context__CROSS_PROFILE_APPS_SERVICE") - .asFunction(); + static final _id_CROSS_PROFILE_APPS_SERVICE = _class.staticFieldId( + r"CROSS_PROFILE_APPS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CROSS_PROFILE_APPS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CROSS_PROFILE_APPS_SERVICE => - _get_CROSS_PROFILE_APPS_SERVICE().object(const jni.JStringType()); + _id_CROSS_PROFILE_APPS_SERVICE.get(_class, const jni.JStringType()); - static final _get_DEVICE_POLICY_SERVICE = - jniLookup>( - "get_Context__DEVICE_POLICY_SERVICE") - .asFunction(); + static final _id_DEVICE_POLICY_SERVICE = _class.staticFieldId( + r"DEVICE_POLICY_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String DEVICE_POLICY_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get DEVICE_POLICY_SERVICE => - _get_DEVICE_POLICY_SERVICE().object(const jni.JStringType()); + _id_DEVICE_POLICY_SERVICE.get(_class, const jni.JStringType()); - static final _get_DISPLAY_HASH_SERVICE = - jniLookup>( - "get_Context__DISPLAY_HASH_SERVICE") - .asFunction(); + static final _id_DISPLAY_HASH_SERVICE = _class.staticFieldId( + r"DISPLAY_HASH_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String DISPLAY_HASH_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get DISPLAY_HASH_SERVICE => - _get_DISPLAY_HASH_SERVICE().object(const jni.JStringType()); + _id_DISPLAY_HASH_SERVICE.get(_class, const jni.JStringType()); - static final _get_DISPLAY_SERVICE = - jniLookup>( - "get_Context__DISPLAY_SERVICE") - .asFunction(); + static final _id_DISPLAY_SERVICE = _class.staticFieldId( + r"DISPLAY_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String DISPLAY_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get DISPLAY_SERVICE => - _get_DISPLAY_SERVICE().object(const jni.JStringType()); + _id_DISPLAY_SERVICE.get(_class, const jni.JStringType()); - static final _get_DOMAIN_VERIFICATION_SERVICE = - jniLookup>( - "get_Context__DOMAIN_VERIFICATION_SERVICE") - .asFunction(); + static final _id_DOMAIN_VERIFICATION_SERVICE = _class.staticFieldId( + r"DOMAIN_VERIFICATION_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String DOMAIN_VERIFICATION_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get DOMAIN_VERIFICATION_SERVICE => - _get_DOMAIN_VERIFICATION_SERVICE().object(const jni.JStringType()); + _id_DOMAIN_VERIFICATION_SERVICE.get(_class, const jni.JStringType()); - static final _get_DOWNLOAD_SERVICE = - jniLookup>( - "get_Context__DOWNLOAD_SERVICE") - .asFunction(); + static final _id_DOWNLOAD_SERVICE = _class.staticFieldId( + r"DOWNLOAD_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String DOWNLOAD_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get DOWNLOAD_SERVICE => - _get_DOWNLOAD_SERVICE().object(const jni.JStringType()); + _id_DOWNLOAD_SERVICE.get(_class, const jni.JStringType()); - static final _get_DROPBOX_SERVICE = - jniLookup>( - "get_Context__DROPBOX_SERVICE") - .asFunction(); + static final _id_DROPBOX_SERVICE = _class.staticFieldId( + r"DROPBOX_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String DROPBOX_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get DROPBOX_SERVICE => - _get_DROPBOX_SERVICE().object(const jni.JStringType()); + _id_DROPBOX_SERVICE.get(_class, const jni.JStringType()); - static final _get_EUICC_SERVICE = - jniLookup>( - "get_Context__EUICC_SERVICE") - .asFunction(); + static final _id_EUICC_SERVICE = _class.staticFieldId( + r"EUICC_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EUICC_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EUICC_SERVICE => - _get_EUICC_SERVICE().object(const jni.JStringType()); + _id_EUICC_SERVICE.get(_class, const jni.JStringType()); - static final _get_FILE_INTEGRITY_SERVICE = - jniLookup>( - "get_Context__FILE_INTEGRITY_SERVICE") - .asFunction(); + static final _id_FILE_INTEGRITY_SERVICE = _class.staticFieldId( + r"FILE_INTEGRITY_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String FILE_INTEGRITY_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get FILE_INTEGRITY_SERVICE => - _get_FILE_INTEGRITY_SERVICE().object(const jni.JStringType()); + _id_FILE_INTEGRITY_SERVICE.get(_class, const jni.JStringType()); - static final _get_FINGERPRINT_SERVICE = - jniLookup>( - "get_Context__FINGERPRINT_SERVICE") - .asFunction(); + static final _id_FINGERPRINT_SERVICE = _class.staticFieldId( + r"FINGERPRINT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String FINGERPRINT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get FINGERPRINT_SERVICE => - _get_FINGERPRINT_SERVICE().object(const jni.JStringType()); + _id_FINGERPRINT_SERVICE.get(_class, const jni.JStringType()); - static final _get_GAME_SERVICE = - jniLookup>( - "get_Context__GAME_SERVICE") - .asFunction(); + static final _id_GAME_SERVICE = _class.staticFieldId( + r"GAME_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String GAME_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get GAME_SERVICE => - _get_GAME_SERVICE().object(const jni.JStringType()); + _id_GAME_SERVICE.get(_class, const jni.JStringType()); - static final _get_HARDWARE_PROPERTIES_SERVICE = - jniLookup>( - "get_Context__HARDWARE_PROPERTIES_SERVICE") - .asFunction(); + static final _id_HARDWARE_PROPERTIES_SERVICE = _class.staticFieldId( + r"HARDWARE_PROPERTIES_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String HARDWARE_PROPERTIES_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get HARDWARE_PROPERTIES_SERVICE => - _get_HARDWARE_PROPERTIES_SERVICE().object(const jni.JStringType()); + _id_HARDWARE_PROPERTIES_SERVICE.get(_class, const jni.JStringType()); - static final _get_INPUT_METHOD_SERVICE = - jniLookup>( - "get_Context__INPUT_METHOD_SERVICE") - .asFunction(); + static final _id_INPUT_METHOD_SERVICE = _class.staticFieldId( + r"INPUT_METHOD_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String INPUT_METHOD_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get INPUT_METHOD_SERVICE => - _get_INPUT_METHOD_SERVICE().object(const jni.JStringType()); + _id_INPUT_METHOD_SERVICE.get(_class, const jni.JStringType()); - static final _get_INPUT_SERVICE = - jniLookup>( - "get_Context__INPUT_SERVICE") - .asFunction(); + static final _id_INPUT_SERVICE = _class.staticFieldId( + r"INPUT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String INPUT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get INPUT_SERVICE => - _get_INPUT_SERVICE().object(const jni.JStringType()); + _id_INPUT_SERVICE.get(_class, const jni.JStringType()); - static final _get_IPSEC_SERVICE = - jniLookup>( - "get_Context__IPSEC_SERVICE") - .asFunction(); + static final _id_IPSEC_SERVICE = _class.staticFieldId( + r"IPSEC_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String IPSEC_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get IPSEC_SERVICE => - _get_IPSEC_SERVICE().object(const jni.JStringType()); + _id_IPSEC_SERVICE.get(_class, const jni.JStringType()); - static final _get_JOB_SCHEDULER_SERVICE = - jniLookup>( - "get_Context__JOB_SCHEDULER_SERVICE") - .asFunction(); + static final _id_JOB_SCHEDULER_SERVICE = _class.staticFieldId( + r"JOB_SCHEDULER_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String JOB_SCHEDULER_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get JOB_SCHEDULER_SERVICE => - _get_JOB_SCHEDULER_SERVICE().object(const jni.JStringType()); + _id_JOB_SCHEDULER_SERVICE.get(_class, const jni.JStringType()); - static final _get_KEYGUARD_SERVICE = - jniLookup>( - "get_Context__KEYGUARD_SERVICE") - .asFunction(); + static final _id_KEYGUARD_SERVICE = _class.staticFieldId( + r"KEYGUARD_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String KEYGUARD_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get KEYGUARD_SERVICE => - _get_KEYGUARD_SERVICE().object(const jni.JStringType()); + _id_KEYGUARD_SERVICE.get(_class, const jni.JStringType()); - static final _get_LAUNCHER_APPS_SERVICE = - jniLookup>( - "get_Context__LAUNCHER_APPS_SERVICE") - .asFunction(); + static final _id_LAUNCHER_APPS_SERVICE = _class.staticFieldId( + r"LAUNCHER_APPS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String LAUNCHER_APPS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get LAUNCHER_APPS_SERVICE => - _get_LAUNCHER_APPS_SERVICE().object(const jni.JStringType()); + _id_LAUNCHER_APPS_SERVICE.get(_class, const jni.JStringType()); - static final _get_LAYOUT_INFLATER_SERVICE = - jniLookup>( - "get_Context__LAYOUT_INFLATER_SERVICE") - .asFunction(); + static final _id_LAYOUT_INFLATER_SERVICE = _class.staticFieldId( + r"LAYOUT_INFLATER_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String LAYOUT_INFLATER_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get LAYOUT_INFLATER_SERVICE => - _get_LAYOUT_INFLATER_SERVICE().object(const jni.JStringType()); + _id_LAYOUT_INFLATER_SERVICE.get(_class, const jni.JStringType()); - static final _get_LOCALE_SERVICE = - jniLookup>( - "get_Context__LOCALE_SERVICE") - .asFunction(); + static final _id_LOCALE_SERVICE = _class.staticFieldId( + r"LOCALE_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String LOCALE_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get LOCALE_SERVICE => - _get_LOCALE_SERVICE().object(const jni.JStringType()); + _id_LOCALE_SERVICE.get(_class, const jni.JStringType()); - static final _get_LOCATION_SERVICE = - jniLookup>( - "get_Context__LOCATION_SERVICE") - .asFunction(); + static final _id_LOCATION_SERVICE = _class.staticFieldId( + r"LOCATION_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String LOCATION_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get LOCATION_SERVICE => - _get_LOCATION_SERVICE().object(const jni.JStringType()); + _id_LOCATION_SERVICE.get(_class, const jni.JStringType()); - static final _get_MEDIA_COMMUNICATION_SERVICE = - jniLookup>( - "get_Context__MEDIA_COMMUNICATION_SERVICE") - .asFunction(); + static final _id_MEDIA_COMMUNICATION_SERVICE = _class.staticFieldId( + r"MEDIA_COMMUNICATION_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String MEDIA_COMMUNICATION_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get MEDIA_COMMUNICATION_SERVICE => - _get_MEDIA_COMMUNICATION_SERVICE().object(const jni.JStringType()); + _id_MEDIA_COMMUNICATION_SERVICE.get(_class, const jni.JStringType()); - static final _get_MEDIA_METRICS_SERVICE = - jniLookup>( - "get_Context__MEDIA_METRICS_SERVICE") - .asFunction(); + static final _id_MEDIA_METRICS_SERVICE = _class.staticFieldId( + r"MEDIA_METRICS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String MEDIA_METRICS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get MEDIA_METRICS_SERVICE => - _get_MEDIA_METRICS_SERVICE().object(const jni.JStringType()); + _id_MEDIA_METRICS_SERVICE.get(_class, const jni.JStringType()); - static final _get_MEDIA_PROJECTION_SERVICE = - jniLookup>( - "get_Context__MEDIA_PROJECTION_SERVICE") - .asFunction(); + static final _id_MEDIA_PROJECTION_SERVICE = _class.staticFieldId( + r"MEDIA_PROJECTION_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String MEDIA_PROJECTION_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get MEDIA_PROJECTION_SERVICE => - _get_MEDIA_PROJECTION_SERVICE().object(const jni.JStringType()); + _id_MEDIA_PROJECTION_SERVICE.get(_class, const jni.JStringType()); - static final _get_MEDIA_ROUTER_SERVICE = - jniLookup>( - "get_Context__MEDIA_ROUTER_SERVICE") - .asFunction(); + static final _id_MEDIA_ROUTER_SERVICE = _class.staticFieldId( + r"MEDIA_ROUTER_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String MEDIA_ROUTER_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get MEDIA_ROUTER_SERVICE => - _get_MEDIA_ROUTER_SERVICE().object(const jni.JStringType()); + _id_MEDIA_ROUTER_SERVICE.get(_class, const jni.JStringType()); - static final _get_MEDIA_SESSION_SERVICE = - jniLookup>( - "get_Context__MEDIA_SESSION_SERVICE") - .asFunction(); + static final _id_MEDIA_SESSION_SERVICE = _class.staticFieldId( + r"MEDIA_SESSION_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String MEDIA_SESSION_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get MEDIA_SESSION_SERVICE => - _get_MEDIA_SESSION_SERVICE().object(const jni.JStringType()); + _id_MEDIA_SESSION_SERVICE.get(_class, const jni.JStringType()); - static final _get_MIDI_SERVICE = - jniLookup>( - "get_Context__MIDI_SERVICE") - .asFunction(); + static final _id_MIDI_SERVICE = _class.staticFieldId( + r"MIDI_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String MIDI_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get MIDI_SERVICE => - _get_MIDI_SERVICE().object(const jni.JStringType()); + _id_MIDI_SERVICE.get(_class, const jni.JStringType()); /// from: static public final int MODE_APPEND static const MODE_APPEND = 32768; @@ -2166,85 +2848,85 @@ class Context extends jni.JObject { /// from: static public final int MODE_WORLD_WRITEABLE static const MODE_WORLD_WRITEABLE = 2; - static final _get_NETWORK_STATS_SERVICE = - jniLookup>( - "get_Context__NETWORK_STATS_SERVICE") - .asFunction(); + static final _id_NETWORK_STATS_SERVICE = _class.staticFieldId( + r"NETWORK_STATS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String NETWORK_STATS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get NETWORK_STATS_SERVICE => - _get_NETWORK_STATS_SERVICE().object(const jni.JStringType()); + _id_NETWORK_STATS_SERVICE.get(_class, const jni.JStringType()); - static final _get_NFC_SERVICE = - jniLookup>( - "get_Context__NFC_SERVICE") - .asFunction(); + static final _id_NFC_SERVICE = _class.staticFieldId( + r"NFC_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String NFC_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get NFC_SERVICE => - _get_NFC_SERVICE().object(const jni.JStringType()); + _id_NFC_SERVICE.get(_class, const jni.JStringType()); - static final _get_NOTIFICATION_SERVICE = - jniLookup>( - "get_Context__NOTIFICATION_SERVICE") - .asFunction(); + static final _id_NOTIFICATION_SERVICE = _class.staticFieldId( + r"NOTIFICATION_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String NOTIFICATION_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get NOTIFICATION_SERVICE => - _get_NOTIFICATION_SERVICE().object(const jni.JStringType()); + _id_NOTIFICATION_SERVICE.get(_class, const jni.JStringType()); - static final _get_NSD_SERVICE = - jniLookup>( - "get_Context__NSD_SERVICE") - .asFunction(); + static final _id_NSD_SERVICE = _class.staticFieldId( + r"NSD_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String NSD_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get NSD_SERVICE => - _get_NSD_SERVICE().object(const jni.JStringType()); + _id_NSD_SERVICE.get(_class, const jni.JStringType()); - static final _get_PEOPLE_SERVICE = - jniLookup>( - "get_Context__PEOPLE_SERVICE") - .asFunction(); + static final _id_PEOPLE_SERVICE = _class.staticFieldId( + r"PEOPLE_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String PEOPLE_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get PEOPLE_SERVICE => - _get_PEOPLE_SERVICE().object(const jni.JStringType()); + _id_PEOPLE_SERVICE.get(_class, const jni.JStringType()); - static final _get_PERFORMANCE_HINT_SERVICE = - jniLookup>( - "get_Context__PERFORMANCE_HINT_SERVICE") - .asFunction(); + static final _id_PERFORMANCE_HINT_SERVICE = _class.staticFieldId( + r"PERFORMANCE_HINT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String PERFORMANCE_HINT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get PERFORMANCE_HINT_SERVICE => - _get_PERFORMANCE_HINT_SERVICE().object(const jni.JStringType()); + _id_PERFORMANCE_HINT_SERVICE.get(_class, const jni.JStringType()); - static final _get_POWER_SERVICE = - jniLookup>( - "get_Context__POWER_SERVICE") - .asFunction(); + static final _id_POWER_SERVICE = _class.staticFieldId( + r"POWER_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String POWER_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get POWER_SERVICE => - _get_POWER_SERVICE().object(const jni.JStringType()); + _id_POWER_SERVICE.get(_class, const jni.JStringType()); - static final _get_PRINT_SERVICE = - jniLookup>( - "get_Context__PRINT_SERVICE") - .asFunction(); + static final _id_PRINT_SERVICE = _class.staticFieldId( + r"PRINT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String PRINT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get PRINT_SERVICE => - _get_PRINT_SERVICE().object(const jni.JStringType()); + _id_PRINT_SERVICE.get(_class, const jni.JStringType()); /// from: static public final int RECEIVER_EXPORTED static const RECEIVER_EXPORTED = 2; @@ -2254,474 +2936,617 @@ class Context extends jni.JObject { /// from: static public final int RECEIVER_VISIBLE_TO_INSTANT_APPS static const RECEIVER_VISIBLE_TO_INSTANT_APPS = 1; - static final _get_RESTRICTIONS_SERVICE = - jniLookup>( - "get_Context__RESTRICTIONS_SERVICE") - .asFunction(); + static final _id_RESTRICTIONS_SERVICE = _class.staticFieldId( + r"RESTRICTIONS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String RESTRICTIONS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get RESTRICTIONS_SERVICE => - _get_RESTRICTIONS_SERVICE().object(const jni.JStringType()); + _id_RESTRICTIONS_SERVICE.get(_class, const jni.JStringType()); - static final _get_ROLE_SERVICE = - jniLookup>( - "get_Context__ROLE_SERVICE") - .asFunction(); + static final _id_ROLE_SERVICE = _class.staticFieldId( + r"ROLE_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ROLE_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ROLE_SERVICE => - _get_ROLE_SERVICE().object(const jni.JStringType()); + _id_ROLE_SERVICE.get(_class, const jni.JStringType()); - static final _get_SEARCH_SERVICE = - jniLookup>( - "get_Context__SEARCH_SERVICE") - .asFunction(); + static final _id_SEARCH_SERVICE = _class.staticFieldId( + r"SEARCH_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String SEARCH_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get SEARCH_SERVICE => - _get_SEARCH_SERVICE().object(const jni.JStringType()); + _id_SEARCH_SERVICE.get(_class, const jni.JStringType()); - static final _get_SENSOR_SERVICE = - jniLookup>( - "get_Context__SENSOR_SERVICE") - .asFunction(); + static final _id_SENSOR_SERVICE = _class.staticFieldId( + r"SENSOR_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String SENSOR_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get SENSOR_SERVICE => - _get_SENSOR_SERVICE().object(const jni.JStringType()); + _id_SENSOR_SERVICE.get(_class, const jni.JStringType()); - static final _get_SHORTCUT_SERVICE = - jniLookup>( - "get_Context__SHORTCUT_SERVICE") - .asFunction(); + static final _id_SHORTCUT_SERVICE = _class.staticFieldId( + r"SHORTCUT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String SHORTCUT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get SHORTCUT_SERVICE => - _get_SHORTCUT_SERVICE().object(const jni.JStringType()); + _id_SHORTCUT_SERVICE.get(_class, const jni.JStringType()); - static final _get_STATUS_BAR_SERVICE = - jniLookup>( - "get_Context__STATUS_BAR_SERVICE") - .asFunction(); + static final _id_STATUS_BAR_SERVICE = _class.staticFieldId( + r"STATUS_BAR_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String STATUS_BAR_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get STATUS_BAR_SERVICE => - _get_STATUS_BAR_SERVICE().object(const jni.JStringType()); + _id_STATUS_BAR_SERVICE.get(_class, const jni.JStringType()); - static final _get_STORAGE_SERVICE = - jniLookup>( - "get_Context__STORAGE_SERVICE") - .asFunction(); + static final _id_STORAGE_SERVICE = _class.staticFieldId( + r"STORAGE_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String STORAGE_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get STORAGE_SERVICE => - _get_STORAGE_SERVICE().object(const jni.JStringType()); + _id_STORAGE_SERVICE.get(_class, const jni.JStringType()); - static final _get_STORAGE_STATS_SERVICE = - jniLookup>( - "get_Context__STORAGE_STATS_SERVICE") - .asFunction(); + static final _id_STORAGE_STATS_SERVICE = _class.staticFieldId( + r"STORAGE_STATS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String STORAGE_STATS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get STORAGE_STATS_SERVICE => - _get_STORAGE_STATS_SERVICE().object(const jni.JStringType()); + _id_STORAGE_STATS_SERVICE.get(_class, const jni.JStringType()); - static final _get_SYSTEM_HEALTH_SERVICE = - jniLookup>( - "get_Context__SYSTEM_HEALTH_SERVICE") - .asFunction(); + static final _id_SYSTEM_HEALTH_SERVICE = _class.staticFieldId( + r"SYSTEM_HEALTH_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String SYSTEM_HEALTH_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get SYSTEM_HEALTH_SERVICE => - _get_SYSTEM_HEALTH_SERVICE().object(const jni.JStringType()); + _id_SYSTEM_HEALTH_SERVICE.get(_class, const jni.JStringType()); - static final _get_TELECOM_SERVICE = - jniLookup>( - "get_Context__TELECOM_SERVICE") - .asFunction(); + static final _id_TELECOM_SERVICE = _class.staticFieldId( + r"TELECOM_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String TELECOM_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get TELECOM_SERVICE => - _get_TELECOM_SERVICE().object(const jni.JStringType()); + _id_TELECOM_SERVICE.get(_class, const jni.JStringType()); - static final _get_TELEPHONY_IMS_SERVICE = - jniLookup>( - "get_Context__TELEPHONY_IMS_SERVICE") - .asFunction(); + static final _id_TELEPHONY_IMS_SERVICE = _class.staticFieldId( + r"TELEPHONY_IMS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String TELEPHONY_IMS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get TELEPHONY_IMS_SERVICE => - _get_TELEPHONY_IMS_SERVICE().object(const jni.JStringType()); + _id_TELEPHONY_IMS_SERVICE.get(_class, const jni.JStringType()); - static final _get_TELEPHONY_SERVICE = - jniLookup>( - "get_Context__TELEPHONY_SERVICE") - .asFunction(); + static final _id_TELEPHONY_SERVICE = _class.staticFieldId( + r"TELEPHONY_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String TELEPHONY_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get TELEPHONY_SERVICE => - _get_TELEPHONY_SERVICE().object(const jni.JStringType()); + _id_TELEPHONY_SERVICE.get(_class, const jni.JStringType()); - static final _get_TELEPHONY_SUBSCRIPTION_SERVICE = - jniLookup>( - "get_Context__TELEPHONY_SUBSCRIPTION_SERVICE") - .asFunction(); + static final _id_TELEPHONY_SUBSCRIPTION_SERVICE = _class.staticFieldId( + r"TELEPHONY_SUBSCRIPTION_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String TELEPHONY_SUBSCRIPTION_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get TELEPHONY_SUBSCRIPTION_SERVICE => - _get_TELEPHONY_SUBSCRIPTION_SERVICE().object(const jni.JStringType()); + _id_TELEPHONY_SUBSCRIPTION_SERVICE.get(_class, const jni.JStringType()); - static final _get_TEXT_CLASSIFICATION_SERVICE = - jniLookup>( - "get_Context__TEXT_CLASSIFICATION_SERVICE") - .asFunction(); + static final _id_TEXT_CLASSIFICATION_SERVICE = _class.staticFieldId( + r"TEXT_CLASSIFICATION_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String TEXT_CLASSIFICATION_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get TEXT_CLASSIFICATION_SERVICE => - _get_TEXT_CLASSIFICATION_SERVICE().object(const jni.JStringType()); + _id_TEXT_CLASSIFICATION_SERVICE.get(_class, const jni.JStringType()); - static final _get_TEXT_SERVICES_MANAGER_SERVICE = - jniLookup>( - "get_Context__TEXT_SERVICES_MANAGER_SERVICE") - .asFunction(); + static final _id_TEXT_SERVICES_MANAGER_SERVICE = _class.staticFieldId( + r"TEXT_SERVICES_MANAGER_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String TEXT_SERVICES_MANAGER_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get TEXT_SERVICES_MANAGER_SERVICE => - _get_TEXT_SERVICES_MANAGER_SERVICE().object(const jni.JStringType()); + _id_TEXT_SERVICES_MANAGER_SERVICE.get(_class, const jni.JStringType()); - static final _get_TV_INPUT_SERVICE = - jniLookup>( - "get_Context__TV_INPUT_SERVICE") - .asFunction(); + static final _id_TV_INPUT_SERVICE = _class.staticFieldId( + r"TV_INPUT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String TV_INPUT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get TV_INPUT_SERVICE => - _get_TV_INPUT_SERVICE().object(const jni.JStringType()); + _id_TV_INPUT_SERVICE.get(_class, const jni.JStringType()); - static final _get_TV_INTERACTIVE_APP_SERVICE = - jniLookup>( - "get_Context__TV_INTERACTIVE_APP_SERVICE") - .asFunction(); + static final _id_TV_INTERACTIVE_APP_SERVICE = _class.staticFieldId( + r"TV_INTERACTIVE_APP_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String TV_INTERACTIVE_APP_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get TV_INTERACTIVE_APP_SERVICE => - _get_TV_INTERACTIVE_APP_SERVICE().object(const jni.JStringType()); + _id_TV_INTERACTIVE_APP_SERVICE.get(_class, const jni.JStringType()); - static final _get_UI_MODE_SERVICE = - jniLookup>( - "get_Context__UI_MODE_SERVICE") - .asFunction(); + static final _id_UI_MODE_SERVICE = _class.staticFieldId( + r"UI_MODE_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String UI_MODE_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get UI_MODE_SERVICE => - _get_UI_MODE_SERVICE().object(const jni.JStringType()); + _id_UI_MODE_SERVICE.get(_class, const jni.JStringType()); - static final _get_USAGE_STATS_SERVICE = - jniLookup>( - "get_Context__USAGE_STATS_SERVICE") - .asFunction(); + static final _id_USAGE_STATS_SERVICE = _class.staticFieldId( + r"USAGE_STATS_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String USAGE_STATS_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get USAGE_STATS_SERVICE => - _get_USAGE_STATS_SERVICE().object(const jni.JStringType()); + _id_USAGE_STATS_SERVICE.get(_class, const jni.JStringType()); - static final _get_USB_SERVICE = - jniLookup>( - "get_Context__USB_SERVICE") - .asFunction(); + static final _id_USB_SERVICE = _class.staticFieldId( + r"USB_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String USB_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get USB_SERVICE => - _get_USB_SERVICE().object(const jni.JStringType()); + _id_USB_SERVICE.get(_class, const jni.JStringType()); - static final _get_USER_SERVICE = - jniLookup>( - "get_Context__USER_SERVICE") - .asFunction(); + static final _id_USER_SERVICE = _class.staticFieldId( + r"USER_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String USER_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get USER_SERVICE => - _get_USER_SERVICE().object(const jni.JStringType()); + _id_USER_SERVICE.get(_class, const jni.JStringType()); - static final _get_VIBRATOR_MANAGER_SERVICE = - jniLookup>( - "get_Context__VIBRATOR_MANAGER_SERVICE") - .asFunction(); + static final _id_VIBRATOR_MANAGER_SERVICE = _class.staticFieldId( + r"VIBRATOR_MANAGER_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String VIBRATOR_MANAGER_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get VIBRATOR_MANAGER_SERVICE => - _get_VIBRATOR_MANAGER_SERVICE().object(const jni.JStringType()); + _id_VIBRATOR_MANAGER_SERVICE.get(_class, const jni.JStringType()); - static final _get_VIBRATOR_SERVICE = - jniLookup>( - "get_Context__VIBRATOR_SERVICE") - .asFunction(); + static final _id_VIBRATOR_SERVICE = _class.staticFieldId( + r"VIBRATOR_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String VIBRATOR_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get VIBRATOR_SERVICE => - _get_VIBRATOR_SERVICE().object(const jni.JStringType()); + _id_VIBRATOR_SERVICE.get(_class, const jni.JStringType()); - static final _get_VPN_MANAGEMENT_SERVICE = - jniLookup>( - "get_Context__VPN_MANAGEMENT_SERVICE") - .asFunction(); + static final _id_VPN_MANAGEMENT_SERVICE = _class.staticFieldId( + r"VPN_MANAGEMENT_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String VPN_MANAGEMENT_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get VPN_MANAGEMENT_SERVICE => - _get_VPN_MANAGEMENT_SERVICE().object(const jni.JStringType()); + _id_VPN_MANAGEMENT_SERVICE.get(_class, const jni.JStringType()); - static final _get_WALLPAPER_SERVICE = - jniLookup>( - "get_Context__WALLPAPER_SERVICE") - .asFunction(); + static final _id_WALLPAPER_SERVICE = _class.staticFieldId( + r"WALLPAPER_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String WALLPAPER_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get WALLPAPER_SERVICE => - _get_WALLPAPER_SERVICE().object(const jni.JStringType()); + _id_WALLPAPER_SERVICE.get(_class, const jni.JStringType()); - static final _get_WIFI_AWARE_SERVICE = - jniLookup>( - "get_Context__WIFI_AWARE_SERVICE") - .asFunction(); + static final _id_WIFI_AWARE_SERVICE = _class.staticFieldId( + r"WIFI_AWARE_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String WIFI_AWARE_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get WIFI_AWARE_SERVICE => - _get_WIFI_AWARE_SERVICE().object(const jni.JStringType()); + _id_WIFI_AWARE_SERVICE.get(_class, const jni.JStringType()); - static final _get_WIFI_P2P_SERVICE = - jniLookup>( - "get_Context__WIFI_P2P_SERVICE") - .asFunction(); + static final _id_WIFI_P2P_SERVICE = _class.staticFieldId( + r"WIFI_P2P_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String WIFI_P2P_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get WIFI_P2P_SERVICE => - _get_WIFI_P2P_SERVICE().object(const jni.JStringType()); + _id_WIFI_P2P_SERVICE.get(_class, const jni.JStringType()); - static final _get_WIFI_RTT_RANGING_SERVICE = - jniLookup>( - "get_Context__WIFI_RTT_RANGING_SERVICE") - .asFunction(); + static final _id_WIFI_RTT_RANGING_SERVICE = _class.staticFieldId( + r"WIFI_RTT_RANGING_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String WIFI_RTT_RANGING_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get WIFI_RTT_RANGING_SERVICE => - _get_WIFI_RTT_RANGING_SERVICE().object(const jni.JStringType()); + _id_WIFI_RTT_RANGING_SERVICE.get(_class, const jni.JStringType()); - static final _get_WIFI_SERVICE = - jniLookup>( - "get_Context__WIFI_SERVICE") - .asFunction(); + static final _id_WIFI_SERVICE = _class.staticFieldId( + r"WIFI_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String WIFI_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get WIFI_SERVICE => - _get_WIFI_SERVICE().object(const jni.JStringType()); + _id_WIFI_SERVICE.get(_class, const jni.JStringType()); - static final _get_WINDOW_SERVICE = - jniLookup>( - "get_Context__WINDOW_SERVICE") - .asFunction(); + static final _id_WINDOW_SERVICE = _class.staticFieldId( + r"WINDOW_SERVICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String WINDOW_SERVICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get WINDOW_SERVICE => - _get_WINDOW_SERVICE().object(const jni.JStringType()); + _id_WINDOW_SERVICE.get(_class, const jni.JStringType()); + + static final _id_new0 = _class.constructorId( + r"()V", + ); - static final _new0 = - jniLookup>("Context__new0") - .asFunction(); + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_NewObject") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void () /// The returned object must be released after use, by calling the [release] method. factory Context() { - return Context.fromReference(_new0().reference); + return Context.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); } - static final _getAssets = jniLookup< - ffi - .NativeFunction)>>( - "Context__getAssets") - .asFunction)>(); + static final _id_getAssets = _class.instanceMethodId( + r"getAssets", + r"()Landroid/content/res/AssetManager;", + ); + + static final _getAssets = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.content.res.AssetManager getAssets() /// The returned object must be released after use, by calling the [release] method. jni.JObject getAssets() { - return _getAssets(reference.pointer).object(const jni.JObjectType()); + return _getAssets(reference.pointer, _id_getAssets as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getResources = jniLookup< - ffi - .NativeFunction)>>( - "Context__getResources") - .asFunction)>(); + static final _id_getResources = _class.instanceMethodId( + r"getResources", + r"()Landroid/content/res/Resources;", + ); + + static final _getResources = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.content.res.Resources getResources() /// The returned object must be released after use, by calling the [release] method. jni.JObject getResources() { - return _getResources(reference.pointer).object(const jni.JObjectType()); + return _getResources( + reference.pointer, _id_getResources as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getPackageManager = jniLookup< - ffi - .NativeFunction)>>( - "Context__getPackageManager") - .asFunction)>(); + static final _id_getPackageManager = _class.instanceMethodId( + r"getPackageManager", + r"()Landroid/content/pm/PackageManager;", + ); + + static final _getPackageManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.content.pm.PackageManager getPackageManager() /// The returned object must be released after use, by calling the [release] method. jni.JObject getPackageManager() { - return _getPackageManager(reference.pointer) + return _getPackageManager( + reference.pointer, _id_getPackageManager as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getContentResolver = jniLookup< - ffi - .NativeFunction)>>( - "Context__getContentResolver") - .asFunction)>(); + static final _id_getContentResolver = _class.instanceMethodId( + r"getContentResolver", + r"()Landroid/content/ContentResolver;", + ); + + static final _getContentResolver = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.content.ContentResolver getContentResolver() /// The returned object must be released after use, by calling the [release] method. jni.JObject getContentResolver() { - return _getContentResolver(reference.pointer) + return _getContentResolver( + reference.pointer, _id_getContentResolver as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getMainLooper = jniLookup< - ffi - .NativeFunction)>>( - "Context__getMainLooper") - .asFunction)>(); + static final _id_getMainLooper = _class.instanceMethodId( + r"getMainLooper", + r"()Landroid/os/Looper;", + ); + + static final _getMainLooper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.os.Looper getMainLooper() /// The returned object must be released after use, by calling the [release] method. jni.JObject getMainLooper() { - return _getMainLooper(reference.pointer).object(const jni.JObjectType()); + return _getMainLooper( + reference.pointer, _id_getMainLooper as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getMainExecutor = jniLookup< - ffi - .NativeFunction)>>( - "Context__getMainExecutor") - .asFunction)>(); + static final _id_getMainExecutor = _class.instanceMethodId( + r"getMainExecutor", + r"()Ljava/util/concurrent/Executor;", + ); + + static final _getMainExecutor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.util.concurrent.Executor getMainExecutor() /// The returned object must be released after use, by calling the [release] method. jni.JObject getMainExecutor() { - return _getMainExecutor(reference.pointer).object(const jni.JObjectType()); + return _getMainExecutor( + reference.pointer, _id_getMainExecutor as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getApplicationContext = jniLookup< - ffi - .NativeFunction)>>( - "Context__getApplicationContext") - .asFunction)>(); + static final _id_getApplicationContext = _class.instanceMethodId( + r"getApplicationContext", + r"()Landroid/content/Context;", + ); + + static final _getApplicationContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.content.Context getApplicationContext() /// The returned object must be released after use, by calling the [release] method. Context getApplicationContext() { - return _getApplicationContext(reference.pointer) + return _getApplicationContext( + reference.pointer, _id_getApplicationContext as jni.JMethodIDPtr) .object(const $ContextType()); } - static final _registerComponentCallbacks = jniLookup< + static final _id_registerComponentCallbacks = _class.instanceMethodId( + r"registerComponentCallbacks", + r"(Landroid/content/ComponentCallbacks;)V", + ); + + static final _registerComponentCallbacks = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Context__registerComponentCallbacks") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void registerComponentCallbacks(android.content.ComponentCallbacks componentCallbacks) void registerComponentCallbacks( jni.JObject componentCallbacks, ) { _registerComponentCallbacks( - reference.pointer, componentCallbacks.reference.pointer) + reference.pointer, + _id_registerComponentCallbacks as jni.JMethodIDPtr, + componentCallbacks.reference.pointer) .check(); } - static final _unregisterComponentCallbacks = jniLookup< + static final _id_unregisterComponentCallbacks = _class.instanceMethodId( + r"unregisterComponentCallbacks", + r"(Landroid/content/ComponentCallbacks;)V", + ); + + static final _unregisterComponentCallbacks = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Context__unregisterComponentCallbacks") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void unregisterComponentCallbacks(android.content.ComponentCallbacks componentCallbacks) void unregisterComponentCallbacks( jni.JObject componentCallbacks, ) { _unregisterComponentCallbacks( - reference.pointer, componentCallbacks.reference.pointer) + reference.pointer, + _id_unregisterComponentCallbacks as jni.JMethodIDPtr, + componentCallbacks.reference.pointer) .check(); } - static final _getText = jniLookup< + static final _id_getText = _class.instanceMethodId( + r"getText", + r"(I)Ljava/lang/CharSequence;", + ); + + static final _getText = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Context__getText") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final java.lang.CharSequence getText(int i) /// The returned object must be released after use, by calling the [release] method. jni.JObject getText( int i, ) { - return _getText(reference.pointer, i).object(const jni.JObjectType()); + return _getText(reference.pointer, _id_getText as jni.JMethodIDPtr, i) + .object(const jni.JObjectType()); } - static final _getString = jniLookup< + static final _id_getString = _class.instanceMethodId( + r"getString", + r"(I)Ljava/lang/String;", + ); + + static final _getString = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Context__getString") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final java.lang.String getString(int i) /// The returned object must be released after use, by calling the [release] method. jni.JString getString( int i, ) { - return _getString(reference.pointer, i).object(const jni.JStringType()); + return _getString(reference.pointer, _id_getString as jni.JMethodIDPtr, i) + .object(const jni.JStringType()); } - static final _getString1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Context__getString1") + static final _id_getString1 = _class.instanceMethodId( + r"getString", + r"(I[Ljava/lang/Object;)Ljava/lang/String;", + ); + + static final _getString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public final java.lang.String getString(int i, java.lang.Object[] objects) /// The returned object must be released after use, by calling the [release] method. @@ -2729,101 +3554,167 @@ class Context extends jni.JObject { int i, jni.JArray objects, ) { - return _getString1(reference.pointer, i, objects.reference.pointer) + return _getString1(reference.pointer, _id_getString1 as jni.JMethodIDPtr, i, + objects.reference.pointer) .object(const jni.JStringType()); } - static final _getColor = jniLookup< + static final _id_getColor = _class.instanceMethodId( + r"getColor", + r"(I)I", + ); + + static final _getColor = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Context__getColor") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final int getColor(int i) int getColor( int i, ) { - return _getColor(reference.pointer, i).integer; + return _getColor(reference.pointer, _id_getColor as jni.JMethodIDPtr, i) + .integer; } - static final _getDrawable = jniLookup< + static final _id_getDrawable = _class.instanceMethodId( + r"getDrawable", + r"(I)Landroid/graphics/drawable/Drawable;", + ); + + static final _getDrawable = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Context__getDrawable") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final android.graphics.drawable.Drawable getDrawable(int i) /// The returned object must be released after use, by calling the [release] method. jni.JObject getDrawable( int i, ) { - return _getDrawable(reference.pointer, i).object(const jni.JObjectType()); + return _getDrawable( + reference.pointer, _id_getDrawable as jni.JMethodIDPtr, i) + .object(const jni.JObjectType()); } - static final _getColorStateList = jniLookup< + static final _id_getColorStateList = _class.instanceMethodId( + r"getColorStateList", + r"(I)Landroid/content/res/ColorStateList;", + ); + + static final _getColorStateList = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Context__getColorStateList") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final android.content.res.ColorStateList getColorStateList(int i) /// The returned object must be released after use, by calling the [release] method. jni.JObject getColorStateList( int i, ) { - return _getColorStateList(reference.pointer, i) + return _getColorStateList( + reference.pointer, _id_getColorStateList as jni.JMethodIDPtr, i) .object(const jni.JObjectType()); } - static final _setTheme = jniLookup< + static final _id_setTheme = _class.instanceMethodId( + r"setTheme", + r"(I)V", + ); + + static final _setTheme = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Context__setTheme") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public abstract void setTheme(int i) void setTheme( int i, ) { - _setTheme(reference.pointer, i).check(); + _setTheme(reference.pointer, _id_setTheme as jni.JMethodIDPtr, i).check(); } - static final _getTheme = jniLookup< - ffi - .NativeFunction)>>( - "Context__getTheme") - .asFunction)>(); + static final _id_getTheme = _class.instanceMethodId( + r"getTheme", + r"()Landroid/content/res/Resources$Theme;", + ); + + static final _getTheme = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.content.res.Resources$Theme getTheme() /// The returned object must be released after use, by calling the [release] method. jni.JObject getTheme() { - return _getTheme(reference.pointer).object(const jni.JObjectType()); + return _getTheme(reference.pointer, _id_getTheme as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _obtainStyledAttributes = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__obtainStyledAttributes") + static final _id_obtainStyledAttributes = _class.instanceMethodId( + r"obtainStyledAttributes", + r"([I)Landroid/content/res/TypedArray;", + ); + + static final _obtainStyledAttributes = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final android.content.res.TypedArray obtainStyledAttributes(int[] is) /// The returned object must be released after use, by calling the [release] method. jni.JObject obtainStyledAttributes( jni.JArray is0, ) { - return _obtainStyledAttributes(reference.pointer, is0.reference.pointer) + return _obtainStyledAttributes( + reference.pointer, + _id_obtainStyledAttributes as jni.JMethodIDPtr, + is0.reference.pointer) .object(const jni.JObjectType()); } - static final _obtainStyledAttributes1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Context__obtainStyledAttributes1") + static final _id_obtainStyledAttributes1 = _class.instanceMethodId( + r"obtainStyledAttributes", + r"(I[I)Landroid/content/res/TypedArray;", + ); + + static final _obtainStyledAttributes1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public final android.content.res.TypedArray obtainStyledAttributes(int i, int[] is) /// The returned object must be released after use, by calling the [release] method. @@ -2831,19 +3722,32 @@ class Context extends jni.JObject { int i, jni.JArray is0, ) { - return _obtainStyledAttributes1(reference.pointer, i, is0.reference.pointer) + return _obtainStyledAttributes1( + reference.pointer, + _id_obtainStyledAttributes1 as jni.JMethodIDPtr, + i, + is0.reference.pointer) .object(const jni.JObjectType()); } - static final _obtainStyledAttributes2 = jniLookup< + static final _id_obtainStyledAttributes2 = _class.instanceMethodId( + r"obtainStyledAttributes", + r"(Landroid/util/AttributeSet;[I)Landroid/content/res/TypedArray;", + ); + + static final _obtainStyledAttributes2 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__obtainStyledAttributes2") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public final android.content.res.TypedArray obtainStyledAttributes(android.util.AttributeSet attributeSet, int[] is) /// The returned object must be released after use, by calling the [release] method. @@ -2851,22 +3755,34 @@ class Context extends jni.JObject { jni.JObject attributeSet, jni.JArray is0, ) { - return _obtainStyledAttributes2(reference.pointer, - attributeSet.reference.pointer, is0.reference.pointer) + return _obtainStyledAttributes2( + reference.pointer, + _id_obtainStyledAttributes2 as jni.JMethodIDPtr, + attributeSet.reference.pointer, + is0.reference.pointer) .object(const jni.JObjectType()); } - static final _obtainStyledAttributes3 = jniLookup< + static final _id_obtainStyledAttributes3 = _class.instanceMethodId( + r"obtainStyledAttributes", + r"(Landroid/util/AttributeSet;[III)Landroid/content/res/TypedArray;", + ); + + static final _obtainStyledAttributes3 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32)>>("Context__obtainStyledAttributes3") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int, int)>(); /// from: public final android.content.res.TypedArray obtainStyledAttributes(android.util.AttributeSet attributeSet, int[] is, int i, int i1) /// The returned object must be released after use, by calling the [release] method. @@ -2876,133 +3792,255 @@ class Context extends jni.JObject { int i, int i1, ) { - return _obtainStyledAttributes3(reference.pointer, - attributeSet.reference.pointer, is0.reference.pointer, i, i1) + return _obtainStyledAttributes3( + reference.pointer, + _id_obtainStyledAttributes3 as jni.JMethodIDPtr, + attributeSet.reference.pointer, + is0.reference.pointer, + i, + i1) .object(const jni.JObjectType()); } - static final _getClassLoader = jniLookup< - ffi - .NativeFunction)>>( - "Context__getClassLoader") - .asFunction)>(); + static final _id_getClassLoader = _class.instanceMethodId( + r"getClassLoader", + r"()Ljava/lang/ClassLoader;", + ); + + static final _getClassLoader = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.lang.ClassLoader getClassLoader() /// The returned object must be released after use, by calling the [release] method. jni.JObject getClassLoader() { - return _getClassLoader(reference.pointer).object(const jni.JObjectType()); + return _getClassLoader( + reference.pointer, _id_getClassLoader as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getPackageName = jniLookup< - ffi - .NativeFunction)>>( - "Context__getPackageName") - .asFunction)>(); + static final _id_getPackageName = _class.instanceMethodId( + r"getPackageName", + r"()Ljava/lang/String;", + ); + + static final _getPackageName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.lang.String getPackageName() /// The returned object must be released after use, by calling the [release] method. jni.JString getPackageName() { - return _getPackageName(reference.pointer).object(const jni.JStringType()); + return _getPackageName( + reference.pointer, _id_getPackageName as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _getOpPackageName = jniLookup< - ffi - .NativeFunction)>>( - "Context__getOpPackageName") - .asFunction)>(); + static final _id_getOpPackageName = _class.instanceMethodId( + r"getOpPackageName", + r"()Ljava/lang/String;", + ); + + static final _getOpPackageName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getOpPackageName() /// The returned object must be released after use, by calling the [release] method. jni.JString getOpPackageName() { - return _getOpPackageName(reference.pointer).object(const jni.JStringType()); + return _getOpPackageName( + reference.pointer, _id_getOpPackageName as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _getAttributionTag = jniLookup< - ffi - .NativeFunction)>>( - "Context__getAttributionTag") - .asFunction)>(); + static final _id_getAttributionTag = _class.instanceMethodId( + r"getAttributionTag", + r"()Ljava/lang/String;", + ); + + static final _getAttributionTag = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getAttributionTag() /// The returned object must be released after use, by calling the [release] method. jni.JString getAttributionTag() { - return _getAttributionTag(reference.pointer) + return _getAttributionTag( + reference.pointer, _id_getAttributionTag as jni.JMethodIDPtr) .object(const jni.JStringType()); } - static final _getAttributionSource = jniLookup< - ffi - .NativeFunction)>>( - "Context__getAttributionSource") - .asFunction)>(); + static final _id_getAttributionSource = _class.instanceMethodId( + r"getAttributionSource", + r"()Landroid/content/AttributionSource;", + ); + + static final _getAttributionSource = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.AttributionSource getAttributionSource() /// The returned object must be released after use, by calling the [release] method. jni.JObject getAttributionSource() { - return _getAttributionSource(reference.pointer) + return _getAttributionSource( + reference.pointer, _id_getAttributionSource as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getParams = jniLookup< - ffi - .NativeFunction)>>( - "Context__getParams") - .asFunction)>(); + static final _id_getParams = _class.instanceMethodId( + r"getParams", + r"()Landroid/content/ContextParams;", + ); + + static final _getParams = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.ContextParams getParams() /// The returned object must be released after use, by calling the [release] method. jni.JObject getParams() { - return _getParams(reference.pointer).object(const jni.JObjectType()); + return _getParams(reference.pointer, _id_getParams as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getApplicationInfo = jniLookup< - ffi - .NativeFunction)>>( - "Context__getApplicationInfo") - .asFunction)>(); + static final _id_getApplicationInfo = _class.instanceMethodId( + r"getApplicationInfo", + r"()Landroid/content/pm/ApplicationInfo;", + ); + + static final _getApplicationInfo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.content.pm.ApplicationInfo getApplicationInfo() /// The returned object must be released after use, by calling the [release] method. jni.JObject getApplicationInfo() { - return _getApplicationInfo(reference.pointer) + return _getApplicationInfo( + reference.pointer, _id_getApplicationInfo as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getPackageResourcePath = jniLookup< - ffi - .NativeFunction)>>( - "Context__getPackageResourcePath") - .asFunction)>(); + static final _id_getPackageResourcePath = _class.instanceMethodId( + r"getPackageResourcePath", + r"()Ljava/lang/String;", + ); + + static final _getPackageResourcePath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.lang.String getPackageResourcePath() /// The returned object must be released after use, by calling the [release] method. jni.JString getPackageResourcePath() { - return _getPackageResourcePath(reference.pointer) + return _getPackageResourcePath( + reference.pointer, _id_getPackageResourcePath as jni.JMethodIDPtr) .object(const jni.JStringType()); } - static final _getPackageCodePath = jniLookup< - ffi - .NativeFunction)>>( - "Context__getPackageCodePath") - .asFunction)>(); + static final _id_getPackageCodePath = _class.instanceMethodId( + r"getPackageCodePath", + r"()Ljava/lang/String;", + ); + + static final _getPackageCodePath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.lang.String getPackageCodePath() /// The returned object must be released after use, by calling the [release] method. jni.JString getPackageCodePath() { - return _getPackageCodePath(reference.pointer) + return _getPackageCodePath( + reference.pointer, _id_getPackageCodePath as jni.JMethodIDPtr) .object(const jni.JStringType()); } - static final _getSharedPreferences = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__getSharedPreferences") + static final _id_getSharedPreferences = _class.instanceMethodId( + r"getSharedPreferences", + r"(Ljava/lang/String;I)Landroid/content/SharedPreferences;", + ); + + static final _getSharedPreferences = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public abstract android.content.SharedPreferences getSharedPreferences(java.lang.String string, int i) /// The returned object must be released after use, by calling the [release] method. @@ -3010,70 +4048,114 @@ class Context extends jni.JObject { jni.JString string, int i, ) { - return _getSharedPreferences(reference.pointer, string.reference.pointer, i) + return _getSharedPreferences( + reference.pointer, + _id_getSharedPreferences as jni.JMethodIDPtr, + string.reference.pointer, + i) .object(const jni.JObjectType()); } - static final _moveSharedPreferencesFrom = jniLookup< + static final _id_moveSharedPreferencesFrom = _class.instanceMethodId( + r"moveSharedPreferencesFrom", + r"(Landroid/content/Context;Ljava/lang/String;)Z", + ); + + static final _moveSharedPreferencesFrom = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__moveSharedPreferencesFrom") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract boolean moveSharedPreferencesFrom(android.content.Context context, java.lang.String string) bool moveSharedPreferencesFrom( Context context, jni.JString string, ) { - return _moveSharedPreferencesFrom(reference.pointer, - context.reference.pointer, string.reference.pointer) + return _moveSharedPreferencesFrom( + reference.pointer, + _id_moveSharedPreferencesFrom as jni.JMethodIDPtr, + context.reference.pointer, + string.reference.pointer) .boolean; } - static final _deleteSharedPreferences = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__deleteSharedPreferences") + static final _id_deleteSharedPreferences = _class.instanceMethodId( + r"deleteSharedPreferences", + r"(Ljava/lang/String;)Z", + ); + + static final _deleteSharedPreferences = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract boolean deleteSharedPreferences(java.lang.String string) bool deleteSharedPreferences( jni.JString string, ) { - return _deleteSharedPreferences(reference.pointer, string.reference.pointer) + return _deleteSharedPreferences( + reference.pointer, + _id_deleteSharedPreferences as jni.JMethodIDPtr, + string.reference.pointer) .boolean; } - static final _openFileInput = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__openFileInput") + static final _id_openFileInput = _class.instanceMethodId( + r"openFileInput", + r"(Ljava/lang/String;)Ljava/io/FileInputStream;", + ); + + static final _openFileInput = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract java.io.FileInputStream openFileInput(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject openFileInput( jni.JString string, ) { - return _openFileInput(reference.pointer, string.reference.pointer) + return _openFileInput(reference.pointer, + _id_openFileInput as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JObjectType()); } - static final _openFileOutput = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int32)>>("Context__openFileOutput") + static final _id_openFileOutput = _class.instanceMethodId( + r"openFileOutput", + r"(Ljava/lang/String;I)Ljava/io/FileOutputStream;", + ); + + static final _openFileOutput = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public abstract java.io.FileOutputStream openFileOutput(java.lang.String string, int i) /// The returned object must be released after use, by calling the [release] method. @@ -3081,221 +4163,402 @@ class Context extends jni.JObject { jni.JString string, int i, ) { - return _openFileOutput(reference.pointer, string.reference.pointer, i) + return _openFileOutput(reference.pointer, + _id_openFileOutput as jni.JMethodIDPtr, string.reference.pointer, i) .object(const jni.JObjectType()); } - static final _deleteFile = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__deleteFile") + static final _id_deleteFile = _class.instanceMethodId( + r"deleteFile", + r"(Ljava/lang/String;)Z", + ); + + static final _deleteFile = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract boolean deleteFile(java.lang.String string) bool deleteFile( jni.JString string, ) { - return _deleteFile(reference.pointer, string.reference.pointer).boolean; + return _deleteFile(reference.pointer, _id_deleteFile as jni.JMethodIDPtr, + string.reference.pointer) + .boolean; } - static final _getFileStreamPath = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__getFileStreamPath") + static final _id_getFileStreamPath = _class.instanceMethodId( + r"getFileStreamPath", + r"(Ljava/lang/String;)Ljava/io/File;", + ); + + static final _getFileStreamPath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract java.io.File getFileStreamPath(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getFileStreamPath( jni.JString string, ) { - return _getFileStreamPath(reference.pointer, string.reference.pointer) + return _getFileStreamPath(reference.pointer, + _id_getFileStreamPath as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JObjectType()); } - static final _getDataDir = jniLookup< - ffi - .NativeFunction)>>( - "Context__getDataDir") - .asFunction)>(); + static final _id_getDataDir = _class.instanceMethodId( + r"getDataDir", + r"()Ljava/io/File;", + ); + + static final _getDataDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File getDataDir() /// The returned object must be released after use, by calling the [release] method. jni.JObject getDataDir() { - return _getDataDir(reference.pointer).object(const jni.JObjectType()); + return _getDataDir(reference.pointer, _id_getDataDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getFilesDir = jniLookup< - ffi - .NativeFunction)>>( - "Context__getFilesDir") - .asFunction)>(); + static final _id_getFilesDir = _class.instanceMethodId( + r"getFilesDir", + r"()Ljava/io/File;", + ); + + static final _getFilesDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File getFilesDir() /// The returned object must be released after use, by calling the [release] method. jni.JObject getFilesDir() { - return _getFilesDir(reference.pointer).object(const jni.JObjectType()); + return _getFilesDir(reference.pointer, _id_getFilesDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getNoBackupFilesDir = jniLookup< - ffi - .NativeFunction)>>( - "Context__getNoBackupFilesDir") - .asFunction)>(); + static final _id_getNoBackupFilesDir = _class.instanceMethodId( + r"getNoBackupFilesDir", + r"()Ljava/io/File;", + ); + + static final _getNoBackupFilesDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File getNoBackupFilesDir() /// The returned object must be released after use, by calling the [release] method. jni.JObject getNoBackupFilesDir() { - return _getNoBackupFilesDir(reference.pointer) + return _getNoBackupFilesDir( + reference.pointer, _id_getNoBackupFilesDir as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getExternalFilesDir = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__getExternalFilesDir") + static final _id_getExternalFilesDir = _class.instanceMethodId( + r"getExternalFilesDir", + r"(Ljava/lang/String;)Ljava/io/File;", + ); + + static final _getExternalFilesDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract java.io.File getExternalFilesDir(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getExternalFilesDir( jni.JString string, ) { - return _getExternalFilesDir(reference.pointer, string.reference.pointer) + return _getExternalFilesDir( + reference.pointer, + _id_getExternalFilesDir as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _getExternalFilesDirs = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__getExternalFilesDirs") + static final _id_getExternalFilesDirs = _class.instanceMethodId( + r"getExternalFilesDirs", + r"(Ljava/lang/String;)[Ljava/io/File;", + ); + + static final _getExternalFilesDirs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract java.io.File[] getExternalFilesDirs(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getExternalFilesDirs( jni.JString string, ) { - return _getExternalFilesDirs(reference.pointer, string.reference.pointer) + return _getExternalFilesDirs( + reference.pointer, + _id_getExternalFilesDirs as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JArrayType(jni.JObjectType())); } - static final _getObbDir = jniLookup< - ffi - .NativeFunction)>>( - "Context__getObbDir") - .asFunction)>(); + static final _id_getObbDir = _class.instanceMethodId( + r"getObbDir", + r"()Ljava/io/File;", + ); + + static final _getObbDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File getObbDir() /// The returned object must be released after use, by calling the [release] method. jni.JObject getObbDir() { - return _getObbDir(reference.pointer).object(const jni.JObjectType()); + return _getObbDir(reference.pointer, _id_getObbDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getObbDirs = jniLookup< - ffi - .NativeFunction)>>( - "Context__getObbDirs") - .asFunction)>(); + static final _id_getObbDirs = _class.instanceMethodId( + r"getObbDirs", + r"()[Ljava/io/File;", + ); + + static final _getObbDirs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File[] getObbDirs() /// The returned object must be released after use, by calling the [release] method. jni.JArray getObbDirs() { - return _getObbDirs(reference.pointer) + return _getObbDirs(reference.pointer, _id_getObbDirs as jni.JMethodIDPtr) .object(const jni.JArrayType(jni.JObjectType())); } - static final _getCacheDir = jniLookup< - ffi - .NativeFunction)>>( - "Context__getCacheDir") - .asFunction)>(); + static final _id_getCacheDir = _class.instanceMethodId( + r"getCacheDir", + r"()Ljava/io/File;", + ); + + static final _getCacheDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File getCacheDir() /// The returned object must be released after use, by calling the [release] method. jni.JObject getCacheDir() { - return _getCacheDir(reference.pointer).object(const jni.JObjectType()); + return _getCacheDir(reference.pointer, _id_getCacheDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getCodeCacheDir = jniLookup< - ffi - .NativeFunction)>>( - "Context__getCodeCacheDir") - .asFunction)>(); + static final _id_getCodeCacheDir = _class.instanceMethodId( + r"getCodeCacheDir", + r"()Ljava/io/File;", + ); + + static final _getCodeCacheDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File getCodeCacheDir() /// The returned object must be released after use, by calling the [release] method. jni.JObject getCodeCacheDir() { - return _getCodeCacheDir(reference.pointer).object(const jni.JObjectType()); + return _getCodeCacheDir( + reference.pointer, _id_getCodeCacheDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getExternalCacheDir = jniLookup< - ffi - .NativeFunction)>>( - "Context__getExternalCacheDir") - .asFunction)>(); + static final _id_getExternalCacheDir = _class.instanceMethodId( + r"getExternalCacheDir", + r"()Ljava/io/File;", + ); + + static final _getExternalCacheDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File getExternalCacheDir() /// The returned object must be released after use, by calling the [release] method. jni.JObject getExternalCacheDir() { - return _getExternalCacheDir(reference.pointer) + return _getExternalCacheDir( + reference.pointer, _id_getExternalCacheDir as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getExternalCacheDirs = jniLookup< - ffi - .NativeFunction)>>( - "Context__getExternalCacheDirs") - .asFunction)>(); + static final _id_getExternalCacheDirs = _class.instanceMethodId( + r"getExternalCacheDirs", + r"()[Ljava/io/File;", + ); + + static final _getExternalCacheDirs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File[] getExternalCacheDirs() /// The returned object must be released after use, by calling the [release] method. jni.JArray getExternalCacheDirs() { - return _getExternalCacheDirs(reference.pointer) + return _getExternalCacheDirs( + reference.pointer, _id_getExternalCacheDirs as jni.JMethodIDPtr) .object(const jni.JArrayType(jni.JObjectType())); } - static final _getExternalMediaDirs = jniLookup< - ffi - .NativeFunction)>>( - "Context__getExternalMediaDirs") - .asFunction)>(); + static final _id_getExternalMediaDirs = _class.instanceMethodId( + r"getExternalMediaDirs", + r"()[Ljava/io/File;", + ); + + static final _getExternalMediaDirs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.io.File[] getExternalMediaDirs() /// The returned object must be released after use, by calling the [release] method. jni.JArray getExternalMediaDirs() { - return _getExternalMediaDirs(reference.pointer) + return _getExternalMediaDirs( + reference.pointer, _id_getExternalMediaDirs as jni.JMethodIDPtr) .object(const jni.JArrayType(jni.JObjectType())); } - static final _fileList = jniLookup< - ffi - .NativeFunction)>>( - "Context__fileList") - .asFunction)>(); + static final _id_fileList = _class.instanceMethodId( + r"fileList", + r"()[Ljava/lang/String;", + ); + + static final _fileList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.lang.String[] fileList() /// The returned object must be released after use, by calling the [release] method. jni.JArray fileList() { - return _fileList(reference.pointer) + return _fileList(reference.pointer, _id_fileList as jni.JMethodIDPtr) .object(const jni.JArrayType(jni.JStringType())); } - static final _getDir = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int32)>>("Context__getDir") + static final _id_getDir = _class.instanceMethodId( + r"getDir", + r"(Ljava/lang/String;I)Ljava/io/File;", + ); + + static final _getDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public abstract java.io.File getDir(java.lang.String string, int i) /// The returned object must be released after use, by calling the [release] method. @@ -3303,20 +4566,30 @@ class Context extends jni.JObject { jni.JString string, int i, ) { - return _getDir(reference.pointer, string.reference.pointer, i) + return _getDir(reference.pointer, _id_getDir as jni.JMethodIDPtr, + string.reference.pointer, i) .object(const jni.JObjectType()); } - static final _openOrCreateDatabase = jniLookup< + static final _id_openOrCreateDatabase = _class.instanceMethodId( + r"openOrCreateDatabase", + r"(Ljava/lang/String;ILandroid/database/sqlite/SQLiteDatabase$CursorFactory;)Landroid/database/sqlite/SQLiteDatabase;", + ); + + static final _openOrCreateDatabase = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("Context__openOrCreateDatabase") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); /// from: public abstract android.database.sqlite.SQLiteDatabase openOrCreateDatabase(java.lang.String string, int i, android.database.sqlite.SQLiteDatabase$CursorFactory cursorFactory) /// The returned object must be released after use, by calling the [release] method. @@ -3325,22 +4598,40 @@ class Context extends jni.JObject { int i, jni.JObject cursorFactory, ) { - return _openOrCreateDatabase(reference.pointer, string.reference.pointer, i, + return _openOrCreateDatabase( + reference.pointer, + _id_openOrCreateDatabase as jni.JMethodIDPtr, + string.reference.pointer, + i, cursorFactory.reference.pointer) .object(const jni.JObjectType()); } - static final _openOrCreateDatabase1 = jniLookup< + static final _id_openOrCreateDatabase1 = _class.instanceMethodId( + r"openOrCreateDatabase", + r"(Ljava/lang/String;ILandroid/database/sqlite/SQLiteDatabase$CursorFactory;Landroid/database/DatabaseErrorHandler;)Landroid/database/sqlite/SQLiteDatabase;", + ); + + static final _openOrCreateDatabase1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer)>>("Context__openOrCreateDatabase1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); /// from: public abstract android.database.sqlite.SQLiteDatabase openOrCreateDatabase(java.lang.String string, int i, android.database.sqlite.SQLiteDatabase$CursorFactory cursorFactory, android.database.DatabaseErrorHandler databaseErrorHandler) /// The returned object must be released after use, by calling the [release] method. @@ -3352,6 +4643,7 @@ class Context extends jni.JObject { ) { return _openOrCreateDatabase1( reference.pointer, + _id_openOrCreateDatabase1 as jni.JMethodIDPtr, string.reference.pointer, i, cursorFactory.reference.pointer, @@ -3359,240 +4651,418 @@ class Context extends jni.JObject { .object(const jni.JObjectType()); } - static final _moveDatabaseFrom = jniLookup< + static final _id_moveDatabaseFrom = _class.instanceMethodId( + r"moveDatabaseFrom", + r"(Landroid/content/Context;Ljava/lang/String;)Z", + ); + + static final _moveDatabaseFrom = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__moveDatabaseFrom") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract boolean moveDatabaseFrom(android.content.Context context, java.lang.String string) bool moveDatabaseFrom( Context context, jni.JString string, ) { - return _moveDatabaseFrom(reference.pointer, context.reference.pointer, + return _moveDatabaseFrom( + reference.pointer, + _id_moveDatabaseFrom as jni.JMethodIDPtr, + context.reference.pointer, string.reference.pointer) .boolean; } - static final _deleteDatabase = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__deleteDatabase") + static final _id_deleteDatabase = _class.instanceMethodId( + r"deleteDatabase", + r"(Ljava/lang/String;)Z", + ); + + static final _deleteDatabase = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract boolean deleteDatabase(java.lang.String string) bool deleteDatabase( jni.JString string, ) { - return _deleteDatabase(reference.pointer, string.reference.pointer).boolean; + return _deleteDatabase(reference.pointer, + _id_deleteDatabase as jni.JMethodIDPtr, string.reference.pointer) + .boolean; } - static final _getDatabasePath = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__getDatabasePath") + static final _id_getDatabasePath = _class.instanceMethodId( + r"getDatabasePath", + r"(Ljava/lang/String;)Ljava/io/File;", + ); + + static final _getDatabasePath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract java.io.File getDatabasePath(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getDatabasePath( jni.JString string, ) { - return _getDatabasePath(reference.pointer, string.reference.pointer) + return _getDatabasePath(reference.pointer, + _id_getDatabasePath as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JObjectType()); } - static final _databaseList = jniLookup< - ffi - .NativeFunction)>>( - "Context__databaseList") - .asFunction)>(); + static final _id_databaseList = _class.instanceMethodId( + r"databaseList", + r"()[Ljava/lang/String;", + ); + + static final _databaseList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract java.lang.String[] databaseList() /// The returned object must be released after use, by calling the [release] method. jni.JArray databaseList() { - return _databaseList(reference.pointer) + return _databaseList( + reference.pointer, _id_databaseList as jni.JMethodIDPtr) .object(const jni.JArrayType(jni.JStringType())); } - static final _getWallpaper = jniLookup< - ffi - .NativeFunction)>>( - "Context__getWallpaper") - .asFunction)>(); + static final _id_getWallpaper = _class.instanceMethodId( + r"getWallpaper", + r"()Landroid/graphics/drawable/Drawable;", + ); + + static final _getWallpaper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.graphics.drawable.Drawable getWallpaper() /// The returned object must be released after use, by calling the [release] method. jni.JObject getWallpaper() { - return _getWallpaper(reference.pointer).object(const jni.JObjectType()); + return _getWallpaper( + reference.pointer, _id_getWallpaper as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _peekWallpaper = jniLookup< - ffi - .NativeFunction)>>( - "Context__peekWallpaper") - .asFunction)>(); + static final _id_peekWallpaper = _class.instanceMethodId( + r"peekWallpaper", + r"()Landroid/graphics/drawable/Drawable;", + ); + + static final _peekWallpaper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.graphics.drawable.Drawable peekWallpaper() /// The returned object must be released after use, by calling the [release] method. jni.JObject peekWallpaper() { - return _peekWallpaper(reference.pointer).object(const jni.JObjectType()); + return _peekWallpaper( + reference.pointer, _id_peekWallpaper as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getWallpaperDesiredMinimumWidth = jniLookup< - ffi - .NativeFunction)>>( - "Context__getWallpaperDesiredMinimumWidth") - .asFunction)>(); + static final _id_getWallpaperDesiredMinimumWidth = _class.instanceMethodId( + r"getWallpaperDesiredMinimumWidth", + r"()I", + ); + + static final _getWallpaperDesiredMinimumWidth = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract int getWallpaperDesiredMinimumWidth() int getWallpaperDesiredMinimumWidth() { - return _getWallpaperDesiredMinimumWidth(reference.pointer).integer; + return _getWallpaperDesiredMinimumWidth(reference.pointer, + _id_getWallpaperDesiredMinimumWidth as jni.JMethodIDPtr) + .integer; } - static final _getWallpaperDesiredMinimumHeight = jniLookup< - ffi - .NativeFunction)>>( - "Context__getWallpaperDesiredMinimumHeight") - .asFunction)>(); + static final _id_getWallpaperDesiredMinimumHeight = _class.instanceMethodId( + r"getWallpaperDesiredMinimumHeight", + r"()I", + ); + + static final _getWallpaperDesiredMinimumHeight = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract int getWallpaperDesiredMinimumHeight() int getWallpaperDesiredMinimumHeight() { - return _getWallpaperDesiredMinimumHeight(reference.pointer).integer; + return _getWallpaperDesiredMinimumHeight(reference.pointer, + _id_getWallpaperDesiredMinimumHeight as jni.JMethodIDPtr) + .integer; } - static final _setWallpaper = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__setWallpaper") + static final _id_setWallpaper = _class.instanceMethodId( + r"setWallpaper", + r"(Landroid/graphics/Bitmap;)V", + ); + + static final _setWallpaper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void setWallpaper(android.graphics.Bitmap bitmap) void setWallpaper( jni.JObject bitmap, ) { - _setWallpaper(reference.pointer, bitmap.reference.pointer).check(); + _setWallpaper(reference.pointer, _id_setWallpaper as jni.JMethodIDPtr, + bitmap.reference.pointer) + .check(); } - static final _setWallpaper1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__setWallpaper1") + static final _id_setWallpaper1 = _class.instanceMethodId( + r"setWallpaper", + r"(Ljava/io/InputStream;)V", + ); + + static final _setWallpaper1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void setWallpaper(java.io.InputStream inputStream) void setWallpaper1( jni.JObject inputStream, ) { - _setWallpaper1(reference.pointer, inputStream.reference.pointer).check(); + _setWallpaper1(reference.pointer, _id_setWallpaper1 as jni.JMethodIDPtr, + inputStream.reference.pointer) + .check(); } - static final _clearWallpaper = jniLookup< - ffi - .NativeFunction)>>( - "Context__clearWallpaper") - .asFunction)>(); + static final _id_clearWallpaper = _class.instanceMethodId( + r"clearWallpaper", + r"()V", + ); + + static final _clearWallpaper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract void clearWallpaper() void clearWallpaper() { - _clearWallpaper(reference.pointer).check(); + _clearWallpaper(reference.pointer, _id_clearWallpaper as jni.JMethodIDPtr) + .check(); } - static final _startActivity = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__startActivity") + static final _id_startActivity = _class.instanceMethodId( + r"startActivity", + r"(Landroid/content/Intent;)V", + ); + + static final _startActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void startActivity(android.content.Intent intent) void startActivity( Intent intent, ) { - _startActivity(reference.pointer, intent.reference.pointer).check(); + _startActivity(reference.pointer, _id_startActivity as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); } - static final _startActivity1 = jniLookup< + static final _id_startActivity1 = _class.instanceMethodId( + r"startActivity", + r"(Landroid/content/Intent;Landroid/os/Bundle;)V", + ); + + static final _startActivity1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Context__startActivity1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void startActivity(android.content.Intent intent, android.os.Bundle bundle) void startActivity1( Intent intent, jni.JObject bundle, ) { - _startActivity1(reference.pointer, intent.reference.pointer, - bundle.reference.pointer) + _startActivity1(reference.pointer, _id_startActivity1 as jni.JMethodIDPtr, + intent.reference.pointer, bundle.reference.pointer) .check(); } - static final _startActivities = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__startActivities") + static final _id_startActivities = _class.instanceMethodId( + r"startActivities", + r"([Landroid/content/Intent;)V", + ); + + static final _startActivities = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void startActivities(android.content.Intent[] intents) void startActivities( jni.JArray intents, ) { - _startActivities(reference.pointer, intents.reference.pointer).check(); + _startActivities(reference.pointer, _id_startActivities as jni.JMethodIDPtr, + intents.reference.pointer) + .check(); } - static final _startActivities1 = jniLookup< + static final _id_startActivities1 = _class.instanceMethodId( + r"startActivities", + r"([Landroid/content/Intent;Landroid/os/Bundle;)V", + ); + + static final _startActivities1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__startActivities1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void startActivities(android.content.Intent[] intents, android.os.Bundle bundle) void startActivities1( jni.JArray intents, jni.JObject bundle, ) { - _startActivities1(reference.pointer, intents.reference.pointer, + _startActivities1( + reference.pointer, + _id_startActivities1 as jni.JMethodIDPtr, + intents.reference.pointer, bundle.reference.pointer) .check(); } - static final _startIntentSender = jniLookup< + static final _id_startIntentSender = _class.instanceMethodId( + r"startIntentSender", + r"(Landroid/content/IntentSender;Landroid/content/Intent;III)V", + ); + + static final _startIntentSender = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32)>>("Context__startIntentSender") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, int, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int, int, int)>(); /// from: public abstract void startIntentSender(android.content.IntentSender intentSender, android.content.Intent intent, int i, int i1, int i2) void startIntentSender( @@ -3602,24 +5072,46 @@ class Context extends jni.JObject { int i1, int i2, ) { - _startIntentSender(reference.pointer, intentSender.reference.pointer, - intent.reference.pointer, i, i1, i2) + _startIntentSender( + reference.pointer, + _id_startIntentSender as jni.JMethodIDPtr, + intentSender.reference.pointer, + intent.reference.pointer, + i, + i1, + i2) .check(); } - static final _startIntentSender1 = jniLookup< + static final _id_startIntentSender1 = _class.instanceMethodId( + r"startIntentSender", + r"(Landroid/content/IntentSender;Landroid/content/Intent;IIILandroid/os/Bundle;)V", + ); + + static final _startIntentSender1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32, - ffi.Pointer)>>("Context__startIntentSender1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, int, int, ffi.Pointer)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); /// from: public abstract void startIntentSender(android.content.IntentSender intentSender, android.content.Intent intent, int i, int i1, int i2, android.os.Bundle bundle) void startIntentSender1( @@ -3630,99 +5122,165 @@ class Context extends jni.JObject { int i2, jni.JObject bundle, ) { - _startIntentSender1(reference.pointer, intentSender.reference.pointer, - intent.reference.pointer, i, i1, i2, bundle.reference.pointer) + _startIntentSender1( + reference.pointer, + _id_startIntentSender1 as jni.JMethodIDPtr, + intentSender.reference.pointer, + intent.reference.pointer, + i, + i1, + i2, + bundle.reference.pointer) .check(); } - static final _sendBroadcast = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__sendBroadcast") + static final _id_sendBroadcast = _class.instanceMethodId( + r"sendBroadcast", + r"(Landroid/content/Intent;)V", + ); + + static final _sendBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void sendBroadcast(android.content.Intent intent) void sendBroadcast( Intent intent, ) { - _sendBroadcast(reference.pointer, intent.reference.pointer).check(); + _sendBroadcast(reference.pointer, _id_sendBroadcast as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); } - static final _sendBroadcast1 = jniLookup< + static final _id_sendBroadcast1 = _class.instanceMethodId( + r"sendBroadcast", + r"(Landroid/content/Intent;Ljava/lang/String;)V", + ); + + static final _sendBroadcast1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Context__sendBroadcast1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void sendBroadcast(android.content.Intent intent, java.lang.String string) void sendBroadcast1( Intent intent, jni.JString string, ) { - _sendBroadcast1(reference.pointer, intent.reference.pointer, - string.reference.pointer) + _sendBroadcast1(reference.pointer, _id_sendBroadcast1 as jni.JMethodIDPtr, + intent.reference.pointer, string.reference.pointer) .check(); } - static final _sendBroadcastWithMultiplePermissions = jniLookup< + static final _id_sendBroadcastWithMultiplePermissions = + _class.instanceMethodId( + r"sendBroadcastWithMultiplePermissions", + r"(Landroid/content/Intent;[Ljava/lang/String;)V", + ); + + static final _sendBroadcastWithMultiplePermissions = + ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "Context__sendBroadcastWithMultiplePermissions") - .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer)>(); /// from: public void sendBroadcastWithMultiplePermissions(android.content.Intent intent, java.lang.String[] strings) void sendBroadcastWithMultiplePermissions( Intent intent, jni.JArray strings, ) { - _sendBroadcastWithMultiplePermissions(reference.pointer, - intent.reference.pointer, strings.reference.pointer) + _sendBroadcastWithMultiplePermissions( + reference.pointer, + _id_sendBroadcastWithMultiplePermissions as jni.JMethodIDPtr, + intent.reference.pointer, + strings.reference.pointer) .check(); } - static final _sendOrderedBroadcast = jniLookup< + static final _id_sendOrderedBroadcast = _class.instanceMethodId( + r"sendOrderedBroadcast", + r"(Landroid/content/Intent;Ljava/lang/String;)V", + ); + + static final _sendOrderedBroadcast = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Context__sendOrderedBroadcast") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void sendOrderedBroadcast(android.content.Intent intent, java.lang.String string) void sendOrderedBroadcast( Intent intent, jni.JString string, ) { - _sendOrderedBroadcast(reference.pointer, intent.reference.pointer, + _sendOrderedBroadcast( + reference.pointer, + _id_sendOrderedBroadcast as jni.JMethodIDPtr, + intent.reference.pointer, string.reference.pointer) .check(); } - static final _sendOrderedBroadcast1 = jniLookup< + static final _id_sendOrderedBroadcast1 = _class.instanceMethodId( + r"sendOrderedBroadcast", + r"(Landroid/content/Intent;Ljava/lang/String;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V", + ); + + static final _sendOrderedBroadcast1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer)>>("Context__sendOrderedBroadcast1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -3743,6 +5301,7 @@ class Context extends jni.JObject { ) { _sendOrderedBroadcast1( reference.pointer, + _id_sendOrderedBroadcast1 as jni.JMethodIDPtr, intent.reference.pointer, string.reference.pointer, broadcastReceiver.reference.pointer, @@ -3753,36 +5312,61 @@ class Context extends jni.JObject { .check(); } - static final _sendBroadcastAsUser = jniLookup< + static final _id_sendBroadcastAsUser = _class.instanceMethodId( + r"sendBroadcastAsUser", + r"(Landroid/content/Intent;Landroid/os/UserHandle;)V", + ); + + static final _sendBroadcastAsUser = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__sendBroadcastAsUser") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void sendBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle) void sendBroadcastAsUser( Intent intent, jni.JObject userHandle, ) { - _sendBroadcastAsUser(reference.pointer, intent.reference.pointer, + _sendBroadcastAsUser( + reference.pointer, + _id_sendBroadcastAsUser as jni.JMethodIDPtr, + intent.reference.pointer, userHandle.reference.pointer) .check(); } - static final _sendBroadcastAsUser1 = jniLookup< + static final _id_sendBroadcastAsUser1 = _class.instanceMethodId( + r"sendBroadcastAsUser", + r"(Landroid/content/Intent;Landroid/os/UserHandle;Ljava/lang/String;)V", + ); + + static final _sendBroadcastAsUser1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Context__sendBroadcastAsUser1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public abstract void sendBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle, java.lang.String string) void sendBroadcastAsUser1( @@ -3790,27 +5374,40 @@ class Context extends jni.JObject { jni.JObject userHandle, jni.JString string, ) { - _sendBroadcastAsUser1(reference.pointer, intent.reference.pointer, - userHandle.reference.pointer, string.reference.pointer) + _sendBroadcastAsUser1( + reference.pointer, + _id_sendBroadcastAsUser1 as jni.JMethodIDPtr, + intent.reference.pointer, + userHandle.reference.pointer, + string.reference.pointer) .check(); } - static final _sendOrderedBroadcastAsUser = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer)>>( - "Context__sendOrderedBroadcastAsUser") + static final _id_sendOrderedBroadcastAsUser = _class.instanceMethodId( + r"sendOrderedBroadcastAsUser", + r"(Landroid/content/Intent;Landroid/os/UserHandle;Ljava/lang/String;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V", + ); + + static final _sendOrderedBroadcastAsUser = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -3833,6 +5430,7 @@ class Context extends jni.JObject { ) { _sendOrderedBroadcastAsUser( reference.pointer, + _id_sendOrderedBroadcastAsUser as jni.JMethodIDPtr, intent.reference.pointer, userHandle.reference.pointer, string.reference.pointer, @@ -3844,21 +5442,31 @@ class Context extends jni.JObject { .check(); } - static final _sendOrderedBroadcast2 = jniLookup< + static final _id_sendOrderedBroadcast2 = _class.instanceMethodId( + r"sendOrderedBroadcast", + r"(Landroid/content/Intent;Ljava/lang/String;Ljava/lang/String;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V", + ); + + static final _sendOrderedBroadcast2 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Context__sendOrderedBroadcast2") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -3881,6 +5489,7 @@ class Context extends jni.JObject { ) { _sendOrderedBroadcast2( reference.pointer, + _id_sendOrderedBroadcast2 as jni.JMethodIDPtr, intent.reference.pointer, string.reference.pointer, string1.reference.pointer, @@ -3892,55 +5501,88 @@ class Context extends jni.JObject { .check(); } - static final _sendStickyBroadcast = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__sendStickyBroadcast") + static final _id_sendStickyBroadcast = _class.instanceMethodId( + r"sendStickyBroadcast", + r"(Landroid/content/Intent;)V", + ); + + static final _sendStickyBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void sendStickyBroadcast(android.content.Intent intent) void sendStickyBroadcast( Intent intent, ) { - _sendStickyBroadcast(reference.pointer, intent.reference.pointer).check(); + _sendStickyBroadcast( + reference.pointer, + _id_sendStickyBroadcast as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); } - static final _sendStickyBroadcast1 = jniLookup< + static final _id_sendStickyBroadcast1 = _class.instanceMethodId( + r"sendStickyBroadcast", + r"(Landroid/content/Intent;Landroid/os/Bundle;)V", + ); + + static final _sendStickyBroadcast1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Context__sendStickyBroadcast1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void sendStickyBroadcast(android.content.Intent intent, android.os.Bundle bundle) void sendStickyBroadcast1( Intent intent, jni.JObject bundle, ) { - _sendStickyBroadcast1(reference.pointer, intent.reference.pointer, + _sendStickyBroadcast1( + reference.pointer, + _id_sendStickyBroadcast1 as jni.JMethodIDPtr, + intent.reference.pointer, bundle.reference.pointer) .check(); } - static final _sendStickyOrderedBroadcast = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer)>>( - "Context__sendStickyOrderedBroadcast") + static final _id_sendStickyOrderedBroadcast = _class.instanceMethodId( + r"sendStickyOrderedBroadcast", + r"(Landroid/content/Intent;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V", + ); + + static final _sendStickyOrderedBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -3959,6 +5601,7 @@ class Context extends jni.JObject { ) { _sendStickyOrderedBroadcast( reference.pointer, + _id_sendStickyOrderedBroadcast as jni.JMethodIDPtr, intent.reference.pointer, broadcastReceiver.reference.pointer, handler.reference.pointer, @@ -3968,63 +5611,97 @@ class Context extends jni.JObject { .check(); } - static final _removeStickyBroadcast = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__removeStickyBroadcast") + static final _id_removeStickyBroadcast = _class.instanceMethodId( + r"removeStickyBroadcast", + r"(Landroid/content/Intent;)V", + ); + + static final _removeStickyBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void removeStickyBroadcast(android.content.Intent intent) void removeStickyBroadcast( Intent intent, ) { - _removeStickyBroadcast(reference.pointer, intent.reference.pointer).check(); + _removeStickyBroadcast( + reference.pointer, + _id_removeStickyBroadcast as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); } - static final _sendStickyBroadcastAsUser = jniLookup< + static final _id_sendStickyBroadcastAsUser = _class.instanceMethodId( + r"sendStickyBroadcastAsUser", + r"(Landroid/content/Intent;Landroid/os/UserHandle;)V", + ); + + static final _sendStickyBroadcastAsUser = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__sendStickyBroadcastAsUser") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void sendStickyBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle) void sendStickyBroadcastAsUser( Intent intent, jni.JObject userHandle, ) { - _sendStickyBroadcastAsUser(reference.pointer, intent.reference.pointer, + _sendStickyBroadcastAsUser( + reference.pointer, + _id_sendStickyBroadcastAsUser as jni.JMethodIDPtr, + intent.reference.pointer, userHandle.reference.pointer) .check(); } - static final _sendStickyOrderedBroadcastAsUser = jniLookup< + static final _id_sendStickyOrderedBroadcastAsUser = _class.instanceMethodId( + r"sendStickyOrderedBroadcastAsUser", + r"(Landroid/content/Intent;Landroid/os/UserHandle;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V", + ); + + static final _sendStickyOrderedBroadcastAsUser = + ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer)>>( - "Context__sendStickyOrderedBroadcastAsUser") - .asFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - int, - ffi.Pointer, - ffi.Pointer)>(); + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); /// from: public abstract void sendStickyOrderedBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle, android.content.BroadcastReceiver broadcastReceiver, android.os.Handler handler, int i, java.lang.String string, android.os.Bundle bundle) void sendStickyOrderedBroadcastAsUser( @@ -4038,6 +5715,7 @@ class Context extends jni.JObject { ) { _sendStickyOrderedBroadcastAsUser( reference.pointer, + _id_sendStickyOrderedBroadcastAsUser as jni.JMethodIDPtr, intent.reference.pointer, userHandle.reference.pointer, broadcastReceiver.reference.pointer, @@ -4048,34 +5726,56 @@ class Context extends jni.JObject { .check(); } - static final _removeStickyBroadcastAsUser = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "Context__removeStickyBroadcastAsUser") + static final _id_removeStickyBroadcastAsUser = _class.instanceMethodId( + r"removeStickyBroadcastAsUser", + r"(Landroid/content/Intent;Landroid/os/UserHandle;)V", + ); + + static final _removeStickyBroadcastAsUser = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void removeStickyBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle) void removeStickyBroadcastAsUser( Intent intent, jni.JObject userHandle, ) { - _removeStickyBroadcastAsUser(reference.pointer, intent.reference.pointer, + _removeStickyBroadcastAsUser( + reference.pointer, + _id_removeStickyBroadcastAsUser as jni.JMethodIDPtr, + intent.reference.pointer, userHandle.reference.pointer) .check(); } - static final _registerReceiver = jniLookup< + static final _id_registerReceiver = _class.instanceMethodId( + r"registerReceiver", + r"(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;)Landroid/content/Intent;", + ); + + static final _registerReceiver = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__registerReceiver") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract android.content.Intent registerReceiver(android.content.BroadcastReceiver broadcastReceiver, android.content.IntentFilter intentFilter) /// The returned object must be released after use, by calling the [release] method. @@ -4083,21 +5783,33 @@ class Context extends jni.JObject { jni.JObject broadcastReceiver, jni.JObject intentFilter, ) { - return _registerReceiver(reference.pointer, - broadcastReceiver.reference.pointer, intentFilter.reference.pointer) + return _registerReceiver( + reference.pointer, + _id_registerReceiver as jni.JMethodIDPtr, + broadcastReceiver.reference.pointer, + intentFilter.reference.pointer) .object(const $IntentType()); } - static final _registerReceiver1 = jniLookup< + static final _id_registerReceiver1 = _class.instanceMethodId( + r"registerReceiver", + r"(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;I)Landroid/content/Intent;", + ); + + static final _registerReceiver1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__registerReceiver1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); /// from: public abstract android.content.Intent registerReceiver(android.content.BroadcastReceiver broadcastReceiver, android.content.IntentFilter intentFilter, int i) /// The returned object must be released after use, by calling the [release] method. @@ -4108,23 +5820,34 @@ class Context extends jni.JObject { ) { return _registerReceiver1( reference.pointer, + _id_registerReceiver1 as jni.JMethodIDPtr, broadcastReceiver.reference.pointer, intentFilter.reference.pointer, i) .object(const $IntentType()); } - static final _registerReceiver2 = jniLookup< + static final _id_registerReceiver2 = _class.instanceMethodId( + r"registerReceiver", + r"(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;Ljava/lang/String;Landroid/os/Handler;)Landroid/content/Intent;", + ); + + static final _registerReceiver2 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__registerReceiver2") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< jni.JniResult Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -4140,6 +5863,7 @@ class Context extends jni.JObject { ) { return _registerReceiver2( reference.pointer, + _id_registerReceiver2 as jni.JMethodIDPtr, broadcastReceiver.reference.pointer, intentFilter.reference.pointer, string.reference.pointer, @@ -4147,18 +5871,28 @@ class Context extends jni.JObject { .object(const $IntentType()); } - static final _registerReceiver3 = jniLookup< + static final _id_registerReceiver3 = _class.instanceMethodId( + r"registerReceiver", + r"(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;Ljava/lang/String;Landroid/os/Handler;I)Landroid/content/Intent;", + ); + + static final _registerReceiver3 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__registerReceiver3") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallObjectMethod") .asFunction< jni.JniResult Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -4176,6 +5910,7 @@ class Context extends jni.JObject { ) { return _registerReceiver3( reference.pointer, + _id_registerReceiver3 as jni.JMethodIDPtr, broadcastReceiver.reference.pointer, intentFilter.reference.pointer, string.reference.pointer, @@ -4184,81 +5919,131 @@ class Context extends jni.JObject { .object(const $IntentType()); } - static final _unregisterReceiver = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__unregisterReceiver") + static final _id_unregisterReceiver = _class.instanceMethodId( + r"unregisterReceiver", + r"(Landroid/content/BroadcastReceiver;)V", + ); + + static final _unregisterReceiver = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void unregisterReceiver(android.content.BroadcastReceiver broadcastReceiver) void unregisterReceiver( jni.JObject broadcastReceiver, ) { - _unregisterReceiver(reference.pointer, broadcastReceiver.reference.pointer) + _unregisterReceiver( + reference.pointer, + _id_unregisterReceiver as jni.JMethodIDPtr, + broadcastReceiver.reference.pointer) .check(); } - static final _startService = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__startService") + static final _id_startService = _class.instanceMethodId( + r"startService", + r"(Landroid/content/Intent;)Landroid/content/ComponentName;", + ); + + static final _startService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract android.content.ComponentName startService(android.content.Intent intent) /// The returned object must be released after use, by calling the [release] method. jni.JObject startService( Intent intent, ) { - return _startService(reference.pointer, intent.reference.pointer) + return _startService(reference.pointer, + _id_startService as jni.JMethodIDPtr, intent.reference.pointer) .object(const jni.JObjectType()); } - static final _startForegroundService = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__startForegroundService") + static final _id_startForegroundService = _class.instanceMethodId( + r"startForegroundService", + r"(Landroid/content/Intent;)Landroid/content/ComponentName;", + ); + + static final _startForegroundService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract android.content.ComponentName startForegroundService(android.content.Intent intent) /// The returned object must be released after use, by calling the [release] method. jni.JObject startForegroundService( Intent intent, ) { - return _startForegroundService(reference.pointer, intent.reference.pointer) + return _startForegroundService( + reference.pointer, + _id_startForegroundService as jni.JMethodIDPtr, + intent.reference.pointer) .object(const jni.JObjectType()); } - static final _stopService = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__stopService") + static final _id_stopService = _class.instanceMethodId( + r"stopService", + r"(Landroid/content/Intent;)Z", + ); + + static final _stopService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract boolean stopService(android.content.Intent intent) bool stopService( Intent intent, ) { - return _stopService(reference.pointer, intent.reference.pointer).boolean; + return _stopService(reference.pointer, _id_stopService as jni.JMethodIDPtr, + intent.reference.pointer) + .boolean; } - static final _bindService = jniLookup< + static final _id_bindService = _class.instanceMethodId( + r"bindService", + r"(Landroid/content/Intent;Landroid/content/ServiceConnection;I)Z", + ); + + static final _bindService = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__bindService") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); /// from: public abstract boolean bindService(android.content.Intent intent, android.content.ServiceConnection serviceConnection, int i) bool bindService( @@ -4266,22 +6051,36 @@ class Context extends jni.JObject { jni.JObject serviceConnection, int i, ) { - return _bindService(reference.pointer, intent.reference.pointer, - serviceConnection.reference.pointer, i) + return _bindService(reference.pointer, _id_bindService as jni.JMethodIDPtr, + intent.reference.pointer, serviceConnection.reference.pointer, i) .boolean; } - static final _bindService1 = jniLookup< + static final _id_bindService1 = _class.instanceMethodId( + r"bindService", + r"(Landroid/content/Intent;ILjava/util/concurrent/Executor;Landroid/content/ServiceConnection;)Z", + ); + + static final _bindService1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer)>>("Context__bindService1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); /// from: public boolean bindService(android.content.Intent intent, int i, java.util.concurrent.Executor executor, android.content.ServiceConnection serviceConnection) bool bindService1( @@ -4290,23 +6089,38 @@ class Context extends jni.JObject { jni.JObject executor, jni.JObject serviceConnection, ) { - return _bindService1(reference.pointer, intent.reference.pointer, i, - executor.reference.pointer, serviceConnection.reference.pointer) + return _bindService1( + reference.pointer, + _id_bindService1 as jni.JMethodIDPtr, + intent.reference.pointer, + i, + executor.reference.pointer, + serviceConnection.reference.pointer) .boolean; } - static final _bindIsolatedService = jniLookup< + static final _id_bindIsolatedService = _class.instanceMethodId( + r"bindIsolatedService", + r"(Landroid/content/Intent;ILjava/lang/String;Ljava/util/concurrent/Executor;Landroid/content/ServiceConnection;)Z", + ); + + static final _bindIsolatedService = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__bindIsolatedService") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< jni.JniResult Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, int, ffi.Pointer, @@ -4323,6 +6137,7 @@ class Context extends jni.JObject { ) { return _bindIsolatedService( reference.pointer, + _id_bindIsolatedService as jni.JMethodIDPtr, intent.reference.pointer, i, string.reference.pointer, @@ -4331,17 +6146,31 @@ class Context extends jni.JObject { .boolean; } - static final _bindServiceAsUser = jniLookup< + static final _id_bindServiceAsUser = _class.instanceMethodId( + r"bindServiceAsUser", + r"(Landroid/content/Intent;Landroid/content/ServiceConnection;ILandroid/os/UserHandle;)Z", + ); + + static final _bindServiceAsUser = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("Context__bindServiceAsUser") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); /// from: public boolean bindServiceAsUser(android.content.Intent intent, android.content.ServiceConnection serviceConnection, int i, android.os.UserHandle userHandle) bool bindServiceAsUser( @@ -4352,6 +6181,7 @@ class Context extends jni.JObject { ) { return _bindServiceAsUser( reference.pointer, + _id_bindServiceAsUser as jni.JMethodIDPtr, intent.reference.pointer, serviceConnection.reference.pointer, i, @@ -4359,16 +6189,25 @@ class Context extends jni.JObject { .boolean; } - static final _updateServiceGroup = jniLookup< + static final _id_updateServiceGroup = _class.instanceMethodId( + r"updateServiceGroup", + r"(Landroid/content/ServiceConnection;II)V", + ); + + static final _updateServiceGroup = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32)>>("Context__updateServiceGroup") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int)>(); /// from: public void updateServiceGroup(android.content.ServiceConnection serviceConnection, int i, int i1) void updateServiceGroup( @@ -4377,36 +6216,62 @@ class Context extends jni.JObject { int i1, ) { _updateServiceGroup( - reference.pointer, serviceConnection.reference.pointer, i, i1) + reference.pointer, + _id_updateServiceGroup as jni.JMethodIDPtr, + serviceConnection.reference.pointer, + i, + i1) .check(); } - static final _unbindService = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__unbindService") + static final _id_unbindService = _class.instanceMethodId( + r"unbindService", + r"(Landroid/content/ServiceConnection;)V", + ); + + static final _unbindService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract void unbindService(android.content.ServiceConnection serviceConnection) void unbindService( jni.JObject serviceConnection, ) { - _unbindService(reference.pointer, serviceConnection.reference.pointer) + _unbindService(reference.pointer, _id_unbindService as jni.JMethodIDPtr, + serviceConnection.reference.pointer) .check(); } - static final _startInstrumentation = jniLookup< + static final _id_startInstrumentation = _class.instanceMethodId( + r"startInstrumentation", + r"(Landroid/content/ComponentName;Ljava/lang/String;Landroid/os/Bundle;)Z", + ); + + static final _startInstrumentation = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Context__startInstrumentation") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public abstract boolean startInstrumentation(android.content.ComponentName componentName, java.lang.String string, android.os.Bundle bundle) bool startInstrumentation( @@ -4416,36 +6281,54 @@ class Context extends jni.JObject { ) { return _startInstrumentation( reference.pointer, + _id_startInstrumentation as jni.JMethodIDPtr, componentName.reference.pointer, string.reference.pointer, bundle.reference.pointer) .boolean; } - static final _getSystemService = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__getSystemService") + static final _id_getSystemService = _class.instanceMethodId( + r"getSystemService", + r"(Ljava/lang/String;)Ljava/lang/Object;", + ); + + static final _getSystemService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract java.lang.Object getSystemService(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getSystemService( jni.JString string, ) { - return _getSystemService(reference.pointer, string.reference.pointer) + return _getSystemService(reference.pointer, + _id_getSystemService as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JObjectType()); } - static final _getSystemService1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__getSystemService1") + static final _id_getSystemService1 = _class.instanceMethodId( + r"getSystemService", + r"(Ljava/lang/Class;)Ljava/lang/Object;", + ); + + static final _getSystemService1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final T getSystemService(java.lang.Class class) /// The returned object must be released after use, by calling the [release] method. @@ -4453,37 +6336,58 @@ class Context extends jni.JObject { jni.JObject class0, { required jni.JObjType<$T> T, }) { - return _getSystemService1(reference.pointer, class0.reference.pointer) + return _getSystemService1(reference.pointer, + _id_getSystemService1 as jni.JMethodIDPtr, class0.reference.pointer) .object(T); } - static final _getSystemServiceName = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__getSystemServiceName") + static final _id_getSystemServiceName = _class.instanceMethodId( + r"getSystemServiceName", + r"(Ljava/lang/Class;)Ljava/lang/String;", + ); + + static final _getSystemServiceName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract java.lang.String getSystemServiceName(java.lang.Class class) /// The returned object must be released after use, by calling the [release] method. jni.JString getSystemServiceName( jni.JObject class0, ) { - return _getSystemServiceName(reference.pointer, class0.reference.pointer) + return _getSystemServiceName( + reference.pointer, + _id_getSystemServiceName as jni.JMethodIDPtr, + class0.reference.pointer) .object(const jni.JStringType()); } - static final _checkPermission = jniLookup< + static final _id_checkPermission = _class.instanceMethodId( + r"checkPermission", + r"(Ljava/lang/String;II)I", + ); + + static final _checkPermission = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32)>>("Context__checkPermission") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int)>(); /// from: public abstract int checkPermission(java.lang.String string, int i, int i1) int checkPermission( @@ -4491,71 +6395,116 @@ class Context extends jni.JObject { int i, int i1, ) { - return _checkPermission(reference.pointer, string.reference.pointer, i, i1) + return _checkPermission( + reference.pointer, + _id_checkPermission as jni.JMethodIDPtr, + string.reference.pointer, + i, + i1) .integer; } - static final _checkCallingPermission = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__checkCallingPermission") + static final _id_checkCallingPermission = _class.instanceMethodId( + r"checkCallingPermission", + r"(Ljava/lang/String;)I", + ); + + static final _checkCallingPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract int checkCallingPermission(java.lang.String string) int checkCallingPermission( jni.JString string, ) { - return _checkCallingPermission(reference.pointer, string.reference.pointer) + return _checkCallingPermission( + reference.pointer, + _id_checkCallingPermission as jni.JMethodIDPtr, + string.reference.pointer) .integer; } - static final _checkCallingOrSelfPermission = jniLookup< + static final _id_checkCallingOrSelfPermission = _class.instanceMethodId( + r"checkCallingOrSelfPermission", + r"(Ljava/lang/String;)I", + ); + + static final _checkCallingOrSelfPermission = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Context__checkCallingOrSelfPermission") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract int checkCallingOrSelfPermission(java.lang.String string) int checkCallingOrSelfPermission( jni.JString string, ) { return _checkCallingOrSelfPermission( - reference.pointer, string.reference.pointer) + reference.pointer, + _id_checkCallingOrSelfPermission as jni.JMethodIDPtr, + string.reference.pointer) .integer; } - static final _checkSelfPermission = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__checkSelfPermission") + static final _id_checkSelfPermission = _class.instanceMethodId( + r"checkSelfPermission", + r"(Ljava/lang/String;)I", + ); + + static final _checkSelfPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract int checkSelfPermission(java.lang.String string) int checkSelfPermission( jni.JString string, ) { - return _checkSelfPermission(reference.pointer, string.reference.pointer) + return _checkSelfPermission( + reference.pointer, + _id_checkSelfPermission as jni.JMethodIDPtr, + string.reference.pointer) .integer; } - static final _enforcePermission = jniLookup< + static final _id_enforcePermission = _class.instanceMethodId( + r"enforcePermission", + r"(Ljava/lang/String;IILjava/lang/String;)V", + ); + + static final _enforcePermission = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Pointer)>>("Context__enforcePermission") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int, ffi.Pointer)>(); /// from: public abstract void enforcePermission(java.lang.String string, int i, int i1, java.lang.String string1) void enforcePermission( @@ -4564,60 +6513,99 @@ class Context extends jni.JObject { int i1, jni.JString string1, ) { - _enforcePermission(reference.pointer, string.reference.pointer, i, i1, + _enforcePermission( + reference.pointer, + _id_enforcePermission as jni.JMethodIDPtr, + string.reference.pointer, + i, + i1, string1.reference.pointer) .check(); } - static final _enforceCallingPermission = jniLookup< + static final _id_enforceCallingPermission = _class.instanceMethodId( + r"enforceCallingPermission", + r"(Ljava/lang/String;Ljava/lang/String;)V", + ); + + static final _enforceCallingPermission = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Context__enforceCallingPermission") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void enforceCallingPermission(java.lang.String string, java.lang.String string1) void enforceCallingPermission( jni.JString string, jni.JString string1, ) { - _enforceCallingPermission(reference.pointer, string.reference.pointer, + _enforceCallingPermission( + reference.pointer, + _id_enforceCallingPermission as jni.JMethodIDPtr, + string.reference.pointer, string1.reference.pointer) .check(); } - static final _enforceCallingOrSelfPermission = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "Context__enforceCallingOrSelfPermission") + static final _id_enforceCallingOrSelfPermission = _class.instanceMethodId( + r"enforceCallingOrSelfPermission", + r"(Ljava/lang/String;Ljava/lang/String;)V", + ); + + static final _enforceCallingOrSelfPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public abstract void enforceCallingOrSelfPermission(java.lang.String string, java.lang.String string1) void enforceCallingOrSelfPermission( jni.JString string, jni.JString string1, ) { - _enforceCallingOrSelfPermission(reference.pointer, string.reference.pointer, + _enforceCallingOrSelfPermission( + reference.pointer, + _id_enforceCallingOrSelfPermission as jni.JMethodIDPtr, + string.reference.pointer, string1.reference.pointer) .check(); } - static final _grantUriPermission = jniLookup< + static final _id_grantUriPermission = _class.instanceMethodId( + r"grantUriPermission", + r"(Ljava/lang/String;Landroid/net/Uri;I)V", + ); + + static final _grantUriPermission = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__grantUriPermission") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); /// from: public abstract void grantUriPermission(java.lang.String string, android.net.Uri uri, int i) void grantUriPermission( @@ -4625,39 +6613,63 @@ class Context extends jni.JObject { jni.JObject uri, int i, ) { - _grantUriPermission(reference.pointer, string.reference.pointer, - uri.reference.pointer, i) + _grantUriPermission( + reference.pointer, + _id_grantUriPermission as jni.JMethodIDPtr, + string.reference.pointer, + uri.reference.pointer, + i) .check(); } - static final _revokeUriPermission = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__revokeUriPermission") + static final _id_revokeUriPermission = _class.instanceMethodId( + r"revokeUriPermission", + r"(Landroid/net/Uri;I)V", + ); + + static final _revokeUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public abstract void revokeUriPermission(android.net.Uri uri, int i) void revokeUriPermission( jni.JObject uri, int i, ) { - _revokeUriPermission(reference.pointer, uri.reference.pointer, i).check(); + _revokeUriPermission( + reference.pointer, + _id_revokeUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i) + .check(); } - static final _revokeUriPermission1 = jniLookup< + static final _id_revokeUriPermission1 = _class.instanceMethodId( + r"revokeUriPermission", + r"(Ljava/lang/String;Landroid/net/Uri;I)V", + ); + + static final _revokeUriPermission1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__revokeUriPermission1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); /// from: public abstract void revokeUriPermission(java.lang.String string, android.net.Uri uri, int i) void revokeUriPermission1( @@ -4665,22 +6677,35 @@ class Context extends jni.JObject { jni.JObject uri, int i, ) { - _revokeUriPermission1(reference.pointer, string.reference.pointer, - uri.reference.pointer, i) + _revokeUriPermission1( + reference.pointer, + _id_revokeUriPermission1 as jni.JMethodIDPtr, + string.reference.pointer, + uri.reference.pointer, + i) .check(); } - static final _checkUriPermission = jniLookup< + static final _id_checkUriPermission = _class.instanceMethodId( + r"checkUriPermission", + r"(Landroid/net/Uri;III)I", + ); + + static final _checkUriPermission = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32)>>("Context__checkUriPermission") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int, int, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int, int)>(); /// from: public abstract int checkUriPermission(android.net.Uri uri, int i, int i1, int i2) int checkUriPermission( @@ -4690,21 +6715,35 @@ class Context extends jni.JObject { int i2, ) { return _checkUriPermission( - reference.pointer, uri.reference.pointer, i, i1, i2) + reference.pointer, + _id_checkUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i, + i1, + i2) .integer; } - static final _checkUriPermissions = jniLookup< + static final _id_checkUriPermissions = _class.instanceMethodId( + r"checkUriPermissions", + r"(Ljava/util/List;III)[I", + ); + + static final _checkUriPermissions = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32)>>("Context__checkUriPermissions") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int, int, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int, int)>(); /// from: public java.lang.Object[] checkUriPermissions(java.util.List list, int i, int i1, int i2) /// The returned object must be released after use, by calling the [release] method. @@ -4715,19 +6754,30 @@ class Context extends jni.JObject { int i2, ) { return _checkUriPermissions( - reference.pointer, list.reference.pointer, i, i1, i2) + reference.pointer, + _id_checkUriPermissions as jni.JMethodIDPtr, + list.reference.pointer, + i, + i1, + i2) .object(const jni.JArrayType(jni.jintType())); } - static final _checkCallingUriPermission = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__checkCallingUriPermission") + static final _id_checkCallingUriPermission = _class.instanceMethodId( + r"checkCallingUriPermission", + r"(Landroid/net/Uri;I)I", + ); + + static final _checkCallingUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public abstract int checkCallingUriPermission(android.net.Uri uri, int i) int checkCallingUriPermission( @@ -4735,19 +6785,28 @@ class Context extends jni.JObject { int i, ) { return _checkCallingUriPermission( - reference.pointer, uri.reference.pointer, i) + reference.pointer, + _id_checkCallingUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i) .integer; } - static final _checkCallingUriPermissions = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__checkCallingUriPermissions") + static final _id_checkCallingUriPermissions = _class.instanceMethodId( + r"checkCallingUriPermissions", + r"(Ljava/util/List;I)[I", + ); + + static final _checkCallingUriPermissions = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public java.lang.Object[] checkCallingUriPermissions(java.util.List list, int i) /// The returned object must be released after use, by calling the [release] method. @@ -4756,19 +6815,28 @@ class Context extends jni.JObject { int i, ) { return _checkCallingUriPermissions( - reference.pointer, list.reference.pointer, i) + reference.pointer, + _id_checkCallingUriPermissions as jni.JMethodIDPtr, + list.reference.pointer, + i) .object(const jni.JArrayType(jni.jintType())); } - static final _checkCallingOrSelfUriPermission = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__checkCallingOrSelfUriPermission") + static final _id_checkCallingOrSelfUriPermission = _class.instanceMethodId( + r"checkCallingOrSelfUriPermission", + r"(Landroid/net/Uri;I)I", + ); + + static final _checkCallingOrSelfUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public abstract int checkCallingOrSelfUriPermission(android.net.Uri uri, int i) int checkCallingOrSelfUriPermission( @@ -4776,19 +6844,29 @@ class Context extends jni.JObject { int i, ) { return _checkCallingOrSelfUriPermission( - reference.pointer, uri.reference.pointer, i) + reference.pointer, + _id_checkCallingOrSelfUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i) .integer; } - static final _checkCallingOrSelfUriPermissions = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__checkCallingOrSelfUriPermissions") - .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + static final _id_checkCallingOrSelfUriPermissions = _class.instanceMethodId( + r"checkCallingOrSelfUriPermissions", + r"(Ljava/util/List;I)[I", + ); + + static final _checkCallingOrSelfUriPermissions = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public java.lang.Object[] checkCallingOrSelfUriPermissions(java.util.List list, int i) /// The returned object must be released after use, by calling the [release] method. @@ -4797,23 +6875,42 @@ class Context extends jni.JObject { int i, ) { return _checkCallingOrSelfUriPermissions( - reference.pointer, list.reference.pointer, i) + reference.pointer, + _id_checkCallingOrSelfUriPermissions as jni.JMethodIDPtr, + list.reference.pointer, + i) .object(const jni.JArrayType(jni.jintType())); } - static final _checkUriPermission1 = jniLookup< + static final _id_checkUriPermission1 = _class.instanceMethodId( + r"checkUriPermission", + r"(Landroid/net/Uri;Ljava/lang/String;Ljava/lang/String;III)I", + ); + + static final _checkUriPermission1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32)>>("Context__checkUriPermission1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer, int, int, int)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int)>(); /// from: public abstract int checkUriPermission(android.net.Uri uri, java.lang.String string, java.lang.String string1, int i, int i1, int i2) int checkUriPermission1( @@ -4824,23 +6921,39 @@ class Context extends jni.JObject { int i1, int i2, ) { - return _checkUriPermission1(reference.pointer, uri.reference.pointer, - string.reference.pointer, string1.reference.pointer, i, i1, i2) + return _checkUriPermission1( + reference.pointer, + _id_checkUriPermission1 as jni.JMethodIDPtr, + uri.reference.pointer, + string.reference.pointer, + string1.reference.pointer, + i, + i1, + i2) .integer; } - static final _enforceUriPermission = jniLookup< + static final _id_enforceUriPermission = _class.instanceMethodId( + r"enforceUriPermission", + r"(Landroid/net/Uri;IIILjava/lang/String;)V", + ); + + static final _enforceUriPermission = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32, - ffi.Pointer)>>("Context__enforceUriPermission") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, int, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int, int, ffi.Pointer)>(); /// from: public abstract void enforceUriPermission(android.net.Uri uri, int i, int i1, int i2, java.lang.String string) void enforceUriPermission( @@ -4850,22 +6963,36 @@ class Context extends jni.JObject { int i2, jni.JString string, ) { - _enforceUriPermission(reference.pointer, uri.reference.pointer, i, i1, i2, + _enforceUriPermission( + reference.pointer, + _id_enforceUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i, + i1, + i2, string.reference.pointer) .check(); } - static final _enforceCallingUriPermission = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>( - "Context__enforceCallingUriPermission") + static final _id_enforceCallingUriPermission = _class.instanceMethodId( + r"enforceCallingUriPermission", + r"(Landroid/net/Uri;ILjava/lang/String;)V", + ); + + static final _enforceCallingUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); /// from: public abstract void enforceCallingUriPermission(android.net.Uri uri, int i, java.lang.String string) void enforceCallingUriPermission( @@ -4873,22 +7000,39 @@ class Context extends jni.JObject { int i, jni.JString string, ) { - _enforceCallingUriPermission(reference.pointer, uri.reference.pointer, i, + _enforceCallingUriPermission( + reference.pointer, + _id_enforceCallingUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i, string.reference.pointer) .check(); } - static final _enforceCallingOrSelfUriPermission = jniLookup< + static final _id_enforceCallingOrSelfUriPermission = _class.instanceMethodId( + r"enforceCallingOrSelfUriPermission", + r"(Landroid/net/Uri;ILjava/lang/String;)V", + ); + + static final _enforceCallingOrSelfUriPermission = + ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>( - "Context__enforceCallingOrSelfUriPermission") - .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer)>(); + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer)>(); /// from: public abstract void enforceCallingOrSelfUriPermission(android.net.Uri uri, int i, java.lang.String string) void enforceCallingOrSelfUriPermission( @@ -4896,25 +7040,39 @@ class Context extends jni.JObject { int i, jni.JString string, ) { - _enforceCallingOrSelfUriPermission(reference.pointer, uri.reference.pointer, - i, string.reference.pointer) + _enforceCallingOrSelfUriPermission( + reference.pointer, + _id_enforceCallingOrSelfUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i, + string.reference.pointer) .check(); } - static final _enforceUriPermission1 = jniLookup< + static final _id_enforceUriPermission1 = _class.instanceMethodId( + r"enforceUriPermission", + r"(Landroid/net/Uri;Ljava/lang/String;Ljava/lang/String;IIILjava/lang/String;)V", + ); + + static final _enforceUriPermission1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32, - ffi.Pointer)>>("Context__enforceUriPermission1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -4935,6 +7093,7 @@ class Context extends jni.JObject { ) { _enforceUriPermission1( reference.pointer, + _id_enforceUriPermission1 as jni.JMethodIDPtr, uri.reference.pointer, string.reference.pointer, string1.reference.pointer, @@ -4945,50 +7104,75 @@ class Context extends jni.JObject { .check(); } - static final _revokeSelfPermissionOnKill = jniLookup< + static final _id_revokeSelfPermissionOnKill = _class.instanceMethodId( + r"revokeSelfPermissionOnKill", + r"(Ljava/lang/String;)V", + ); + + static final _revokeSelfPermissionOnKill = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Context__revokeSelfPermissionOnKill") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void revokeSelfPermissionOnKill(java.lang.String string) void revokeSelfPermissionOnKill( jni.JString string, ) { - _revokeSelfPermissionOnKill(reference.pointer, string.reference.pointer) + _revokeSelfPermissionOnKill( + reference.pointer, + _id_revokeSelfPermissionOnKill as jni.JMethodIDPtr, + string.reference.pointer) .check(); } - static final _revokeSelfPermissionsOnKill = jniLookup< + static final _id_revokeSelfPermissionsOnKill = _class.instanceMethodId( + r"revokeSelfPermissionsOnKill", + r"(Ljava/util/Collection;)V", + ); + + static final _revokeSelfPermissionsOnKill = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Context__revokeSelfPermissionsOnKill") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void revokeSelfPermissionsOnKill(java.util.Collection collection) void revokeSelfPermissionsOnKill( jni.JObject collection, ) { _revokeSelfPermissionsOnKill( - reference.pointer, collection.reference.pointer) + reference.pointer, + _id_revokeSelfPermissionsOnKill as jni.JMethodIDPtr, + collection.reference.pointer) .check(); } - static final _createPackageContext = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Context__createPackageContext") + static final _id_createPackageContext = _class.instanceMethodId( + r"createPackageContext", + r"(Ljava/lang/String;I)Landroid/content/Context;", + ); + + static final _createPackageContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public abstract android.content.Context createPackageContext(java.lang.String string, int i) /// The returned object must be released after use, by calling the [release] method. @@ -4996,35 +7180,57 @@ class Context extends jni.JObject { jni.JString string, int i, ) { - return _createPackageContext(reference.pointer, string.reference.pointer, i) + return _createPackageContext( + reference.pointer, + _id_createPackageContext as jni.JMethodIDPtr, + string.reference.pointer, + i) .object(const $ContextType()); } - static final _createContextForSplit = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__createContextForSplit") + static final _id_createContextForSplit = _class.instanceMethodId( + r"createContextForSplit", + r"(Ljava/lang/String;)Landroid/content/Context;", + ); + + static final _createContextForSplit = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract android.content.Context createContextForSplit(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. Context createContextForSplit( jni.JString string, ) { - return _createContextForSplit(reference.pointer, string.reference.pointer) + return _createContextForSplit( + reference.pointer, + _id_createContextForSplit as jni.JMethodIDPtr, + string.reference.pointer) .object(const $ContextType()); } - static final _createConfigurationContext = jniLookup< + static final _id_createConfigurationContext = _class.instanceMethodId( + r"createConfigurationContext", + r"(Landroid/content/res/Configuration;)Landroid/content/Context;", + ); + + static final _createConfigurationContext = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Context__createConfigurationContext") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract android.content.Context createConfigurationContext(android.content.res.Configuration configuration) /// The returned object must be released after use, by calling the [release] method. @@ -5032,34 +7238,55 @@ class Context extends jni.JObject { jni.JObject configuration, ) { return _createConfigurationContext( - reference.pointer, configuration.reference.pointer) + reference.pointer, + _id_createConfigurationContext as jni.JMethodIDPtr, + configuration.reference.pointer) .object(const $ContextType()); } - static final _createDisplayContext = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__createDisplayContext") + static final _id_createDisplayContext = _class.instanceMethodId( + r"createDisplayContext", + r"(Landroid/view/Display;)Landroid/content/Context;", + ); + + static final _createDisplayContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public abstract android.content.Context createDisplayContext(android.view.Display display) /// The returned object must be released after use, by calling the [release] method. Context createDisplayContext( jni.JObject display, ) { - return _createDisplayContext(reference.pointer, display.reference.pointer) + return _createDisplayContext( + reference.pointer, + _id_createDisplayContext as jni.JMethodIDPtr, + display.reference.pointer) .object(const $ContextType()); } - static final _createWindowContext = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Context__createWindowContext") + static final _id_createWindowContext = _class.instanceMethodId( + r"createWindowContext", + r"(ILandroid/os/Bundle;)Landroid/content/Context;", + ); + + static final _createWindowContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public android.content.Context createWindowContext(int i, android.os.Bundle bundle) /// The returned object must be released after use, by calling the [release] method. @@ -5067,20 +7294,33 @@ class Context extends jni.JObject { int i, jni.JObject bundle, ) { - return _createWindowContext(reference.pointer, i, bundle.reference.pointer) + return _createWindowContext( + reference.pointer, + _id_createWindowContext as jni.JMethodIDPtr, + i, + bundle.reference.pointer) .object(const $ContextType()); } - static final _createWindowContext1 = jniLookup< + static final _id_createWindowContext1 = _class.instanceMethodId( + r"createWindowContext", + r"(Landroid/view/Display;ILandroid/os/Bundle;)Landroid/content/Context;", + ); + + static final _createWindowContext1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("Context__createWindowContext1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); /// from: public android.content.Context createWindowContext(android.view.Display display, int i, android.os.Bundle bundle) /// The returned object must be released after use, by calling the [release] method. @@ -5089,35 +7329,58 @@ class Context extends jni.JObject { int i, jni.JObject bundle, ) { - return _createWindowContext1(reference.pointer, display.reference.pointer, - i, bundle.reference.pointer) + return _createWindowContext1( + reference.pointer, + _id_createWindowContext1 as jni.JMethodIDPtr, + display.reference.pointer, + i, + bundle.reference.pointer) .object(const $ContextType()); } - static final _createContext = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__createContext") + static final _id_createContext = _class.instanceMethodId( + r"createContext", + r"(Landroid/content/ContextParams;)Landroid/content/Context;", + ); + + static final _createContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Context createContext(android.content.ContextParams contextParams) /// The returned object must be released after use, by calling the [release] method. Context createContext( jni.JObject contextParams, ) { - return _createContext(reference.pointer, contextParams.reference.pointer) + return _createContext( + reference.pointer, + _id_createContext as jni.JMethodIDPtr, + contextParams.reference.pointer) .object(const $ContextType()); } - static final _createAttributionContext = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Context__createAttributionContext") + static final _id_createAttributionContext = _class.instanceMethodId( + r"createAttributionContext", + r"(Ljava/lang/String;)Landroid/content/Context;", + ); + + static final _createAttributionContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Context createAttributionContext(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -5125,66 +7388,132 @@ class Context extends jni.JObject { jni.JString string, ) { return _createAttributionContext( - reference.pointer, string.reference.pointer) + reference.pointer, + _id_createAttributionContext as jni.JMethodIDPtr, + string.reference.pointer) .object(const $ContextType()); } - static final _createDeviceProtectedStorageContext = jniLookup< - ffi - .NativeFunction)>>( - "Context__createDeviceProtectedStorageContext") - .asFunction)>(); + static final _id_createDeviceProtectedStorageContext = + _class.instanceMethodId( + r"createDeviceProtectedStorageContext", + r"()Landroid/content/Context;", + ); + + static final _createDeviceProtectedStorageContext = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract android.content.Context createDeviceProtectedStorageContext() /// The returned object must be released after use, by calling the [release] method. Context createDeviceProtectedStorageContext() { - return _createDeviceProtectedStorageContext(reference.pointer) + return _createDeviceProtectedStorageContext(reference.pointer, + _id_createDeviceProtectedStorageContext as jni.JMethodIDPtr) .object(const $ContextType()); } - static final _getDisplay = jniLookup< - ffi - .NativeFunction)>>( - "Context__getDisplay") - .asFunction)>(); + static final _id_getDisplay = _class.instanceMethodId( + r"getDisplay", + r"()Landroid/view/Display;", + ); + + static final _getDisplay = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.view.Display getDisplay() /// The returned object must be released after use, by calling the [release] method. jni.JObject getDisplay() { - return _getDisplay(reference.pointer).object(const jni.JObjectType()); + return _getDisplay(reference.pointer, _id_getDisplay as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _isRestricted = jniLookup< - ffi - .NativeFunction)>>( - "Context__isRestricted") - .asFunction)>(); + static final _id_isRestricted = _class.instanceMethodId( + r"isRestricted", + r"()Z", + ); + + static final _isRestricted = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isRestricted() bool isRestricted() { - return _isRestricted(reference.pointer).boolean; + return _isRestricted( + reference.pointer, _id_isRestricted as jni.JMethodIDPtr) + .boolean; } - static final _isDeviceProtectedStorage = jniLookup< - ffi - .NativeFunction)>>( - "Context__isDeviceProtectedStorage") - .asFunction)>(); + static final _id_isDeviceProtectedStorage = _class.instanceMethodId( + r"isDeviceProtectedStorage", + r"()Z", + ); + + static final _isDeviceProtectedStorage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public abstract boolean isDeviceProtectedStorage() bool isDeviceProtectedStorage() { - return _isDeviceProtectedStorage(reference.pointer).boolean; + return _isDeviceProtectedStorage( + reference.pointer, _id_isDeviceProtectedStorage as jni.JMethodIDPtr) + .boolean; } - static final _isUiContext = jniLookup< - ffi - .NativeFunction)>>( - "Context__isUiContext") - .asFunction)>(); + static final _id_isUiContext = _class.instanceMethodId( + r"isUiContext", + r"()Z", + ); + + static final _isUiContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isUiContext() bool isUiContext() { - return _isUiContext(reference.pointer).boolean; + return _isUiContext(reference.pointer, _id_isUiContext as jni.JMethodIDPtr) + .boolean; } } @@ -5219,62 +7548,109 @@ class Intent_FilterComparison extends jni.JObject { late final jni.JObjType $type = type; Intent_FilterComparison.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r"android/content/Intent$FilterComparison"); /// The type which includes information such as the signature of this class. static const type = $Intent_FilterComparisonType(); - static final _new0 = jniLookup< - ffi - .NativeFunction)>>( - "Intent_FilterComparison__new0") - .asFunction)>(); + static final _id_new0 = _class.constructorId( + r"(Landroid/content/Intent;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_NewObject") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void (android.content.Intent intent) /// The returned object must be released after use, by calling the [release] method. factory Intent_FilterComparison( Intent intent, ) { - return Intent_FilterComparison.fromReference( - _new0(intent.reference.pointer).reference); + return Intent_FilterComparison.fromReference(_new0(_class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, intent.reference.pointer) + .reference); } - static final _getIntent = jniLookup< - ffi - .NativeFunction)>>( - "Intent_FilterComparison__getIntent") - .asFunction)>(); + static final _id_getIntent = _class.instanceMethodId( + r"getIntent", + r"()Landroid/content/Intent;", + ); + + static final _getIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.Intent getIntent() /// The returned object must be released after use, by calling the [release] method. Intent getIntent() { - return _getIntent(reference.pointer).object(const $IntentType()); + return _getIntent(reference.pointer, _id_getIntent as jni.JMethodIDPtr) + .object(const $IntentType()); } - static final _equals = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent_FilterComparison__equals") + static final _id_equals = _class.instanceMethodId( + r"equals", + r"(Ljava/lang/Object;)Z", + ); + + static final _equals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean equals(java.lang.Object object) bool equals( jni.JObject object, ) { - return _equals(reference.pointer, object.reference.pointer).boolean; + return _equals(reference.pointer, _id_equals as jni.JMethodIDPtr, + object.reference.pointer) + .boolean; } - static final _hashCode1 = jniLookup< - ffi - .NativeFunction)>>( - "Intent_FilterComparison__hashCode1") - .asFunction)>(); + static final _id_hashCode1 = _class.instanceMethodId( + r"hashCode", + r"()I", + ); + + static final _hashCode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int hashCode() int hashCode1() { - return _hashCode1(reference.pointer).integer; + return _hashCode1(reference.pointer, _id_hashCode1 as jni.JMethodIDPtr) + .integer; } } @@ -5311,92 +7687,93 @@ class Intent_ShortcutIconResource extends jni.JObject { late final jni.JObjType $type = type; Intent_ShortcutIconResource.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r"android/content/Intent$ShortcutIconResource"); /// The type which includes information such as the signature of this class. static const type = $Intent_ShortcutIconResourceType(); - static final _get_CREATOR = - jniLookup>( - "get_Intent_ShortcutIconResource__CREATOR") - .asFunction(); + static final _id_CREATOR = _class.staticFieldId( + r"CREATOR", + r"Landroid/os/Parcelable$Creator;", + ); /// from: static public final android.os.Parcelable$Creator CREATOR /// The returned object must be released after use, by calling the [release] method. static jni.JObject get CREATOR => - _get_CREATOR().object(const jni.JObjectType()); - - static final _get_packageName = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - jni.JObjectPtr, - )>>("get_Intent_ShortcutIconResource__packageName") - .asFunction< - jni.JniResult Function( - jni.JObjectPtr, - )>(); + _id_CREATOR.get(_class, const jni.JObjectType()); - static final _set_packageName = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - jni.JObjectPtr, ffi.Pointer)>>( - "set_Intent_ShortcutIconResource__packageName") - .asFunction< - jni.JniResult Function(jni.JObjectPtr, ffi.Pointer)>(); + static final _id_packageName = _class.instanceFieldId( + r"packageName", + r"Ljava/lang/String;", + ); /// from: public java.lang.String packageName /// The returned object must be released after use, by calling the [release] method. jni.JString get packageName => - _get_packageName(reference.pointer).object(const jni.JStringType()); + _id_packageName.get(this, const jni.JStringType()); /// from: public java.lang.String packageName /// The returned object must be released after use, by calling the [release] method. set packageName(jni.JString value) => - _set_packageName(reference.pointer, value.reference.pointer).check(); - - static final _get_resourceName = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - jni.JObjectPtr, - )>>("get_Intent_ShortcutIconResource__resourceName") - .asFunction< - jni.JniResult Function( - jni.JObjectPtr, - )>(); + _id_packageName.set(this, const jni.JStringType(), value); - static final _set_resourceName = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - jni.JObjectPtr, ffi.Pointer)>>( - "set_Intent_ShortcutIconResource__resourceName") - .asFunction< - jni.JniResult Function(jni.JObjectPtr, ffi.Pointer)>(); + static final _id_resourceName = _class.instanceFieldId( + r"resourceName", + r"Ljava/lang/String;", + ); /// from: public java.lang.String resourceName /// The returned object must be released after use, by calling the [release] method. jni.JString get resourceName => - _get_resourceName(reference.pointer).object(const jni.JStringType()); + _id_resourceName.get(this, const jni.JStringType()); /// from: public java.lang.String resourceName /// The returned object must be released after use, by calling the [release] method. set resourceName(jni.JString value) => - _set_resourceName(reference.pointer, value.reference.pointer).check(); + _id_resourceName.set(this, const jni.JStringType(), value); - static final _new0 = jniLookup>( - "Intent_ShortcutIconResource__new0") - .asFunction(); + static final _id_new0 = _class.constructorId( + r"()V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_NewObject") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void () /// The returned object must be released after use, by calling the [release] method. factory Intent_ShortcutIconResource() { - return Intent_ShortcutIconResource.fromReference(_new0().reference); + return Intent_ShortcutIconResource.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); } - static final _fromContext = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Intent_ShortcutIconResource__fromContext") - .asFunction, int)>(); + static final _id_fromContext = _class.staticMethodId( + r"fromContext", + r"(Landroid/content/Context;I)Landroid/content/Intent$ShortcutIconResource;", + ); + + static final _fromContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: static public android.content.Intent$ShortcutIconResource fromContext(android.content.Context context, int i) /// The returned object must be released after use, by calling the [release] method. @@ -5404,49 +7781,83 @@ class Intent_ShortcutIconResource extends jni.JObject { Context context, int i, ) { - return _fromContext(context.reference.pointer, i) + return _fromContext(_class.reference.pointer, + _id_fromContext as jni.JMethodIDPtr, context.reference.pointer, i) .object(const $Intent_ShortcutIconResourceType()); } - static final _describeContents = jniLookup< - ffi - .NativeFunction)>>( - "Intent_ShortcutIconResource__describeContents") - .asFunction)>(); + static final _id_describeContents = _class.instanceMethodId( + r"describeContents", + r"()I", + ); + + static final _describeContents = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int describeContents() int describeContents() { - return _describeContents(reference.pointer).integer; + return _describeContents( + reference.pointer, _id_describeContents as jni.JMethodIDPtr) + .integer; } - static final _writeToParcel = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Intent_ShortcutIconResource__writeToParcel") + static final _id_writeToParcel = _class.instanceMethodId( + r"writeToParcel", + r"(Landroid/os/Parcel;I)V", + ); + + static final _writeToParcel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public void writeToParcel(android.os.Parcel parcel, int i) void writeToParcel( jni.JObject parcel, int i, ) { - _writeToParcel(reference.pointer, parcel.reference.pointer, i).check(); + _writeToParcel(reference.pointer, _id_writeToParcel as jni.JMethodIDPtr, + parcel.reference.pointer, i) + .check(); } - static final _toString1 = jniLookup< - ffi - .NativeFunction)>>( - "Intent_ShortcutIconResource__toString1") - .asFunction)>(); + static final _id_toString1 = _class.instanceMethodId( + r"toString", + r"()Ljava/lang/String;", + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String toString() /// The returned object must be released after use, by calling the [release] method. jni.JString toString1() { - return _toString1(reference.pointer).object(const jni.JStringType()); + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); } } @@ -5483,2108 +7894,2122 @@ class Intent extends jni.JObject { late final jni.JObjType $type = type; Intent.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r"android/content/Intent"); /// The type which includes information such as the signature of this class. static const type = $IntentType(); - static final _get_ACTION_AIRPLANE_MODE_CHANGED = - jniLookup>( - "get_Intent__ACTION_AIRPLANE_MODE_CHANGED") - .asFunction(); + static final _id_ACTION_AIRPLANE_MODE_CHANGED = _class.staticFieldId( + r"ACTION_AIRPLANE_MODE_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_AIRPLANE_MODE_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_AIRPLANE_MODE_CHANGED => - _get_ACTION_AIRPLANE_MODE_CHANGED().object(const jni.JStringType()); + _id_ACTION_AIRPLANE_MODE_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_ALL_APPS = - jniLookup>( - "get_Intent__ACTION_ALL_APPS") - .asFunction(); + static final _id_ACTION_ALL_APPS = _class.staticFieldId( + r"ACTION_ALL_APPS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_ALL_APPS /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_ALL_APPS => - _get_ACTION_ALL_APPS().object(const jni.JStringType()); + _id_ACTION_ALL_APPS.get(_class, const jni.JStringType()); - static final _get_ACTION_ANSWER = - jniLookup>( - "get_Intent__ACTION_ANSWER") - .asFunction(); + static final _id_ACTION_ANSWER = _class.staticFieldId( + r"ACTION_ANSWER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_ANSWER /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_ANSWER => - _get_ACTION_ANSWER().object(const jni.JStringType()); + _id_ACTION_ANSWER.get(_class, const jni.JStringType()); - static final _get_ACTION_APPLICATION_LOCALE_CHANGED = - jniLookup>( - "get_Intent__ACTION_APPLICATION_LOCALE_CHANGED") - .asFunction(); + static final _id_ACTION_APPLICATION_LOCALE_CHANGED = _class.staticFieldId( + r"ACTION_APPLICATION_LOCALE_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_APPLICATION_LOCALE_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_APPLICATION_LOCALE_CHANGED => - _get_ACTION_APPLICATION_LOCALE_CHANGED().object(const jni.JStringType()); + _id_ACTION_APPLICATION_LOCALE_CHANGED.get( + _class, const jni.JStringType()); - static final _get_ACTION_APPLICATION_PREFERENCES = - jniLookup>( - "get_Intent__ACTION_APPLICATION_PREFERENCES") - .asFunction(); + static final _id_ACTION_APPLICATION_PREFERENCES = _class.staticFieldId( + r"ACTION_APPLICATION_PREFERENCES", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_APPLICATION_PREFERENCES /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_APPLICATION_PREFERENCES => - _get_ACTION_APPLICATION_PREFERENCES().object(const jni.JStringType()); + _id_ACTION_APPLICATION_PREFERENCES.get(_class, const jni.JStringType()); - static final _get_ACTION_APPLICATION_RESTRICTIONS_CHANGED = - jniLookup>( - "get_Intent__ACTION_APPLICATION_RESTRICTIONS_CHANGED") - .asFunction(); + static final _id_ACTION_APPLICATION_RESTRICTIONS_CHANGED = + _class.staticFieldId( + r"ACTION_APPLICATION_RESTRICTIONS_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_APPLICATION_RESTRICTIONS_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_APPLICATION_RESTRICTIONS_CHANGED => - _get_ACTION_APPLICATION_RESTRICTIONS_CHANGED() - .object(const jni.JStringType()); + _id_ACTION_APPLICATION_RESTRICTIONS_CHANGED.get( + _class, const jni.JStringType()); - static final _get_ACTION_APP_ERROR = - jniLookup>( - "get_Intent__ACTION_APP_ERROR") - .asFunction(); + static final _id_ACTION_APP_ERROR = _class.staticFieldId( + r"ACTION_APP_ERROR", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_APP_ERROR /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_APP_ERROR => - _get_ACTION_APP_ERROR().object(const jni.JStringType()); + _id_ACTION_APP_ERROR.get(_class, const jni.JStringType()); - static final _get_ACTION_ASSIST = - jniLookup>( - "get_Intent__ACTION_ASSIST") - .asFunction(); + static final _id_ACTION_ASSIST = _class.staticFieldId( + r"ACTION_ASSIST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_ASSIST /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_ASSIST => - _get_ACTION_ASSIST().object(const jni.JStringType()); + _id_ACTION_ASSIST.get(_class, const jni.JStringType()); - static final _get_ACTION_ATTACH_DATA = - jniLookup>( - "get_Intent__ACTION_ATTACH_DATA") - .asFunction(); + static final _id_ACTION_ATTACH_DATA = _class.staticFieldId( + r"ACTION_ATTACH_DATA", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_ATTACH_DATA /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_ATTACH_DATA => - _get_ACTION_ATTACH_DATA().object(const jni.JStringType()); + _id_ACTION_ATTACH_DATA.get(_class, const jni.JStringType()); - static final _get_ACTION_AUTO_REVOKE_PERMISSIONS = - jniLookup>( - "get_Intent__ACTION_AUTO_REVOKE_PERMISSIONS") - .asFunction(); + static final _id_ACTION_AUTO_REVOKE_PERMISSIONS = _class.staticFieldId( + r"ACTION_AUTO_REVOKE_PERMISSIONS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_AUTO_REVOKE_PERMISSIONS /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_AUTO_REVOKE_PERMISSIONS => - _get_ACTION_AUTO_REVOKE_PERMISSIONS().object(const jni.JStringType()); + _id_ACTION_AUTO_REVOKE_PERMISSIONS.get(_class, const jni.JStringType()); - static final _get_ACTION_BATTERY_CHANGED = - jniLookup>( - "get_Intent__ACTION_BATTERY_CHANGED") - .asFunction(); + static final _id_ACTION_BATTERY_CHANGED = _class.staticFieldId( + r"ACTION_BATTERY_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_BATTERY_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_BATTERY_CHANGED => - _get_ACTION_BATTERY_CHANGED().object(const jni.JStringType()); + _id_ACTION_BATTERY_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_BATTERY_LOW = - jniLookup>( - "get_Intent__ACTION_BATTERY_LOW") - .asFunction(); + static final _id_ACTION_BATTERY_LOW = _class.staticFieldId( + r"ACTION_BATTERY_LOW", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_BATTERY_LOW /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_BATTERY_LOW => - _get_ACTION_BATTERY_LOW().object(const jni.JStringType()); + _id_ACTION_BATTERY_LOW.get(_class, const jni.JStringType()); - static final _get_ACTION_BATTERY_OKAY = - jniLookup>( - "get_Intent__ACTION_BATTERY_OKAY") - .asFunction(); + static final _id_ACTION_BATTERY_OKAY = _class.staticFieldId( + r"ACTION_BATTERY_OKAY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_BATTERY_OKAY /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_BATTERY_OKAY => - _get_ACTION_BATTERY_OKAY().object(const jni.JStringType()); + _id_ACTION_BATTERY_OKAY.get(_class, const jni.JStringType()); - static final _get_ACTION_BOOT_COMPLETED = - jniLookup>( - "get_Intent__ACTION_BOOT_COMPLETED") - .asFunction(); + static final _id_ACTION_BOOT_COMPLETED = _class.staticFieldId( + r"ACTION_BOOT_COMPLETED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_BOOT_COMPLETED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_BOOT_COMPLETED => - _get_ACTION_BOOT_COMPLETED().object(const jni.JStringType()); + _id_ACTION_BOOT_COMPLETED.get(_class, const jni.JStringType()); - static final _get_ACTION_BUG_REPORT = - jniLookup>( - "get_Intent__ACTION_BUG_REPORT") - .asFunction(); + static final _id_ACTION_BUG_REPORT = _class.staticFieldId( + r"ACTION_BUG_REPORT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_BUG_REPORT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_BUG_REPORT => - _get_ACTION_BUG_REPORT().object(const jni.JStringType()); + _id_ACTION_BUG_REPORT.get(_class, const jni.JStringType()); - static final _get_ACTION_CALL = - jniLookup>( - "get_Intent__ACTION_CALL") - .asFunction(); + static final _id_ACTION_CALL = _class.staticFieldId( + r"ACTION_CALL", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CALL /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CALL => - _get_ACTION_CALL().object(const jni.JStringType()); + _id_ACTION_CALL.get(_class, const jni.JStringType()); - static final _get_ACTION_CALL_BUTTON = - jniLookup>( - "get_Intent__ACTION_CALL_BUTTON") - .asFunction(); + static final _id_ACTION_CALL_BUTTON = _class.staticFieldId( + r"ACTION_CALL_BUTTON", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CALL_BUTTON /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CALL_BUTTON => - _get_ACTION_CALL_BUTTON().object(const jni.JStringType()); + _id_ACTION_CALL_BUTTON.get(_class, const jni.JStringType()); - static final _get_ACTION_CAMERA_BUTTON = - jniLookup>( - "get_Intent__ACTION_CAMERA_BUTTON") - .asFunction(); + static final _id_ACTION_CAMERA_BUTTON = _class.staticFieldId( + r"ACTION_CAMERA_BUTTON", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CAMERA_BUTTON /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CAMERA_BUTTON => - _get_ACTION_CAMERA_BUTTON().object(const jni.JStringType()); + _id_ACTION_CAMERA_BUTTON.get(_class, const jni.JStringType()); - static final _get_ACTION_CARRIER_SETUP = - jniLookup>( - "get_Intent__ACTION_CARRIER_SETUP") - .asFunction(); + static final _id_ACTION_CARRIER_SETUP = _class.staticFieldId( + r"ACTION_CARRIER_SETUP", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CARRIER_SETUP /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CARRIER_SETUP => - _get_ACTION_CARRIER_SETUP().object(const jni.JStringType()); + _id_ACTION_CARRIER_SETUP.get(_class, const jni.JStringType()); - static final _get_ACTION_CHOOSER = - jniLookup>( - "get_Intent__ACTION_CHOOSER") - .asFunction(); + static final _id_ACTION_CHOOSER = _class.staticFieldId( + r"ACTION_CHOOSER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CHOOSER /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CHOOSER => - _get_ACTION_CHOOSER().object(const jni.JStringType()); + _id_ACTION_CHOOSER.get(_class, const jni.JStringType()); - static final _get_ACTION_CLOSE_SYSTEM_DIALOGS = - jniLookup>( - "get_Intent__ACTION_CLOSE_SYSTEM_DIALOGS") - .asFunction(); + static final _id_ACTION_CLOSE_SYSTEM_DIALOGS = _class.staticFieldId( + r"ACTION_CLOSE_SYSTEM_DIALOGS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CLOSE_SYSTEM_DIALOGS /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CLOSE_SYSTEM_DIALOGS => - _get_ACTION_CLOSE_SYSTEM_DIALOGS().object(const jni.JStringType()); + _id_ACTION_CLOSE_SYSTEM_DIALOGS.get(_class, const jni.JStringType()); - static final _get_ACTION_CONFIGURATION_CHANGED = - jniLookup>( - "get_Intent__ACTION_CONFIGURATION_CHANGED") - .asFunction(); + static final _id_ACTION_CONFIGURATION_CHANGED = _class.staticFieldId( + r"ACTION_CONFIGURATION_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CONFIGURATION_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CONFIGURATION_CHANGED => - _get_ACTION_CONFIGURATION_CHANGED().object(const jni.JStringType()); + _id_ACTION_CONFIGURATION_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_CREATE_DOCUMENT = - jniLookup>( - "get_Intent__ACTION_CREATE_DOCUMENT") - .asFunction(); + static final _id_ACTION_CREATE_DOCUMENT = _class.staticFieldId( + r"ACTION_CREATE_DOCUMENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CREATE_DOCUMENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CREATE_DOCUMENT => - _get_ACTION_CREATE_DOCUMENT().object(const jni.JStringType()); + _id_ACTION_CREATE_DOCUMENT.get(_class, const jni.JStringType()); - static final _get_ACTION_CREATE_REMINDER = - jniLookup>( - "get_Intent__ACTION_CREATE_REMINDER") - .asFunction(); + static final _id_ACTION_CREATE_REMINDER = _class.staticFieldId( + r"ACTION_CREATE_REMINDER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CREATE_REMINDER /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CREATE_REMINDER => - _get_ACTION_CREATE_REMINDER().object(const jni.JStringType()); + _id_ACTION_CREATE_REMINDER.get(_class, const jni.JStringType()); - static final _get_ACTION_CREATE_SHORTCUT = - jniLookup>( - "get_Intent__ACTION_CREATE_SHORTCUT") - .asFunction(); + static final _id_ACTION_CREATE_SHORTCUT = _class.staticFieldId( + r"ACTION_CREATE_SHORTCUT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_CREATE_SHORTCUT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_CREATE_SHORTCUT => - _get_ACTION_CREATE_SHORTCUT().object(const jni.JStringType()); + _id_ACTION_CREATE_SHORTCUT.get(_class, const jni.JStringType()); - static final _get_ACTION_DATE_CHANGED = - jniLookup>( - "get_Intent__ACTION_DATE_CHANGED") - .asFunction(); + static final _id_ACTION_DATE_CHANGED = _class.staticFieldId( + r"ACTION_DATE_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DATE_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DATE_CHANGED => - _get_ACTION_DATE_CHANGED().object(const jni.JStringType()); + _id_ACTION_DATE_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_DEFAULT = - jniLookup>( - "get_Intent__ACTION_DEFAULT") - .asFunction(); + static final _id_ACTION_DEFAULT = _class.staticFieldId( + r"ACTION_DEFAULT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DEFAULT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DEFAULT => - _get_ACTION_DEFAULT().object(const jni.JStringType()); + _id_ACTION_DEFAULT.get(_class, const jni.JStringType()); - static final _get_ACTION_DEFINE = - jniLookup>( - "get_Intent__ACTION_DEFINE") - .asFunction(); + static final _id_ACTION_DEFINE = _class.staticFieldId( + r"ACTION_DEFINE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DEFINE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DEFINE => - _get_ACTION_DEFINE().object(const jni.JStringType()); + _id_ACTION_DEFINE.get(_class, const jni.JStringType()); - static final _get_ACTION_DELETE = - jniLookup>( - "get_Intent__ACTION_DELETE") - .asFunction(); + static final _id_ACTION_DELETE = _class.staticFieldId( + r"ACTION_DELETE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DELETE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DELETE => - _get_ACTION_DELETE().object(const jni.JStringType()); + _id_ACTION_DELETE.get(_class, const jni.JStringType()); - static final _get_ACTION_DEVICE_STORAGE_LOW = - jniLookup>( - "get_Intent__ACTION_DEVICE_STORAGE_LOW") - .asFunction(); + static final _id_ACTION_DEVICE_STORAGE_LOW = _class.staticFieldId( + r"ACTION_DEVICE_STORAGE_LOW", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DEVICE_STORAGE_LOW /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DEVICE_STORAGE_LOW => - _get_ACTION_DEVICE_STORAGE_LOW().object(const jni.JStringType()); + _id_ACTION_DEVICE_STORAGE_LOW.get(_class, const jni.JStringType()); - static final _get_ACTION_DEVICE_STORAGE_OK = - jniLookup>( - "get_Intent__ACTION_DEVICE_STORAGE_OK") - .asFunction(); + static final _id_ACTION_DEVICE_STORAGE_OK = _class.staticFieldId( + r"ACTION_DEVICE_STORAGE_OK", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DEVICE_STORAGE_OK /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DEVICE_STORAGE_OK => - _get_ACTION_DEVICE_STORAGE_OK().object(const jni.JStringType()); + _id_ACTION_DEVICE_STORAGE_OK.get(_class, const jni.JStringType()); - static final _get_ACTION_DIAL = - jniLookup>( - "get_Intent__ACTION_DIAL") - .asFunction(); + static final _id_ACTION_DIAL = _class.staticFieldId( + r"ACTION_DIAL", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DIAL /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DIAL => - _get_ACTION_DIAL().object(const jni.JStringType()); + _id_ACTION_DIAL.get(_class, const jni.JStringType()); - static final _get_ACTION_DOCK_EVENT = - jniLookup>( - "get_Intent__ACTION_DOCK_EVENT") - .asFunction(); + static final _id_ACTION_DOCK_EVENT = _class.staticFieldId( + r"ACTION_DOCK_EVENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DOCK_EVENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DOCK_EVENT => - _get_ACTION_DOCK_EVENT().object(const jni.JStringType()); + _id_ACTION_DOCK_EVENT.get(_class, const jni.JStringType()); - static final _get_ACTION_DREAMING_STARTED = - jniLookup>( - "get_Intent__ACTION_DREAMING_STARTED") - .asFunction(); + static final _id_ACTION_DREAMING_STARTED = _class.staticFieldId( + r"ACTION_DREAMING_STARTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DREAMING_STARTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DREAMING_STARTED => - _get_ACTION_DREAMING_STARTED().object(const jni.JStringType()); + _id_ACTION_DREAMING_STARTED.get(_class, const jni.JStringType()); - static final _get_ACTION_DREAMING_STOPPED = - jniLookup>( - "get_Intent__ACTION_DREAMING_STOPPED") - .asFunction(); + static final _id_ACTION_DREAMING_STOPPED = _class.staticFieldId( + r"ACTION_DREAMING_STOPPED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_DREAMING_STOPPED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_DREAMING_STOPPED => - _get_ACTION_DREAMING_STOPPED().object(const jni.JStringType()); + _id_ACTION_DREAMING_STOPPED.get(_class, const jni.JStringType()); - static final _get_ACTION_EDIT = - jniLookup>( - "get_Intent__ACTION_EDIT") - .asFunction(); + static final _id_ACTION_EDIT = _class.staticFieldId( + r"ACTION_EDIT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_EDIT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_EDIT => - _get_ACTION_EDIT().object(const jni.JStringType()); + _id_ACTION_EDIT.get(_class, const jni.JStringType()); - static final _get_ACTION_EXTERNAL_APPLICATIONS_AVAILABLE = - jniLookup>( - "get_Intent__ACTION_EXTERNAL_APPLICATIONS_AVAILABLE") - .asFunction(); + static final _id_ACTION_EXTERNAL_APPLICATIONS_AVAILABLE = + _class.staticFieldId( + r"ACTION_EXTERNAL_APPLICATIONS_AVAILABLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_EXTERNAL_APPLICATIONS_AVAILABLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_EXTERNAL_APPLICATIONS_AVAILABLE => - _get_ACTION_EXTERNAL_APPLICATIONS_AVAILABLE() - .object(const jni.JStringType()); + _id_ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.get( + _class, const jni.JStringType()); - static final _get_ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE = - jniLookup>( - "get_Intent__ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE") - .asFunction(); + static final _id_ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE = + _class.staticFieldId( + r"ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE => - _get_ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE() - .object(const jni.JStringType()); + _id_ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.get( + _class, const jni.JStringType()); - static final _get_ACTION_FACTORY_TEST = - jniLookup>( - "get_Intent__ACTION_FACTORY_TEST") - .asFunction(); + static final _id_ACTION_FACTORY_TEST = _class.staticFieldId( + r"ACTION_FACTORY_TEST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_FACTORY_TEST /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_FACTORY_TEST => - _get_ACTION_FACTORY_TEST().object(const jni.JStringType()); + _id_ACTION_FACTORY_TEST.get(_class, const jni.JStringType()); - static final _get_ACTION_GET_CONTENT = - jniLookup>( - "get_Intent__ACTION_GET_CONTENT") - .asFunction(); + static final _id_ACTION_GET_CONTENT = _class.staticFieldId( + r"ACTION_GET_CONTENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_GET_CONTENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_GET_CONTENT => - _get_ACTION_GET_CONTENT().object(const jni.JStringType()); + _id_ACTION_GET_CONTENT.get(_class, const jni.JStringType()); - static final _get_ACTION_GET_RESTRICTION_ENTRIES = - jniLookup>( - "get_Intent__ACTION_GET_RESTRICTION_ENTRIES") - .asFunction(); + static final _id_ACTION_GET_RESTRICTION_ENTRIES = _class.staticFieldId( + r"ACTION_GET_RESTRICTION_ENTRIES", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_GET_RESTRICTION_ENTRIES /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_GET_RESTRICTION_ENTRIES => - _get_ACTION_GET_RESTRICTION_ENTRIES().object(const jni.JStringType()); + _id_ACTION_GET_RESTRICTION_ENTRIES.get(_class, const jni.JStringType()); - static final _get_ACTION_GTALK_SERVICE_CONNECTED = - jniLookup>( - "get_Intent__ACTION_GTALK_SERVICE_CONNECTED") - .asFunction(); + static final _id_ACTION_GTALK_SERVICE_CONNECTED = _class.staticFieldId( + r"ACTION_GTALK_SERVICE_CONNECTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_GTALK_SERVICE_CONNECTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_GTALK_SERVICE_CONNECTED => - _get_ACTION_GTALK_SERVICE_CONNECTED().object(const jni.JStringType()); + _id_ACTION_GTALK_SERVICE_CONNECTED.get(_class, const jni.JStringType()); - static final _get_ACTION_GTALK_SERVICE_DISCONNECTED = - jniLookup>( - "get_Intent__ACTION_GTALK_SERVICE_DISCONNECTED") - .asFunction(); + static final _id_ACTION_GTALK_SERVICE_DISCONNECTED = _class.staticFieldId( + r"ACTION_GTALK_SERVICE_DISCONNECTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_GTALK_SERVICE_DISCONNECTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_GTALK_SERVICE_DISCONNECTED => - _get_ACTION_GTALK_SERVICE_DISCONNECTED().object(const jni.JStringType()); + _id_ACTION_GTALK_SERVICE_DISCONNECTED.get( + _class, const jni.JStringType()); - static final _get_ACTION_HEADSET_PLUG = - jniLookup>( - "get_Intent__ACTION_HEADSET_PLUG") - .asFunction(); + static final _id_ACTION_HEADSET_PLUG = _class.staticFieldId( + r"ACTION_HEADSET_PLUG", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_HEADSET_PLUG /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_HEADSET_PLUG => - _get_ACTION_HEADSET_PLUG().object(const jni.JStringType()); + _id_ACTION_HEADSET_PLUG.get(_class, const jni.JStringType()); - static final _get_ACTION_INPUT_METHOD_CHANGED = - jniLookup>( - "get_Intent__ACTION_INPUT_METHOD_CHANGED") - .asFunction(); + static final _id_ACTION_INPUT_METHOD_CHANGED = _class.staticFieldId( + r"ACTION_INPUT_METHOD_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_INPUT_METHOD_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_INPUT_METHOD_CHANGED => - _get_ACTION_INPUT_METHOD_CHANGED().object(const jni.JStringType()); + _id_ACTION_INPUT_METHOD_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_INSERT = - jniLookup>( - "get_Intent__ACTION_INSERT") - .asFunction(); + static final _id_ACTION_INSERT = _class.staticFieldId( + r"ACTION_INSERT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_INSERT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_INSERT => - _get_ACTION_INSERT().object(const jni.JStringType()); + _id_ACTION_INSERT.get(_class, const jni.JStringType()); - static final _get_ACTION_INSERT_OR_EDIT = - jniLookup>( - "get_Intent__ACTION_INSERT_OR_EDIT") - .asFunction(); + static final _id_ACTION_INSERT_OR_EDIT = _class.staticFieldId( + r"ACTION_INSERT_OR_EDIT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_INSERT_OR_EDIT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_INSERT_OR_EDIT => - _get_ACTION_INSERT_OR_EDIT().object(const jni.JStringType()); + _id_ACTION_INSERT_OR_EDIT.get(_class, const jni.JStringType()); - static final _get_ACTION_INSTALL_FAILURE = - jniLookup>( - "get_Intent__ACTION_INSTALL_FAILURE") - .asFunction(); + static final _id_ACTION_INSTALL_FAILURE = _class.staticFieldId( + r"ACTION_INSTALL_FAILURE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_INSTALL_FAILURE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_INSTALL_FAILURE => - _get_ACTION_INSTALL_FAILURE().object(const jni.JStringType()); + _id_ACTION_INSTALL_FAILURE.get(_class, const jni.JStringType()); - static final _get_ACTION_INSTALL_PACKAGE = - jniLookup>( - "get_Intent__ACTION_INSTALL_PACKAGE") - .asFunction(); + static final _id_ACTION_INSTALL_PACKAGE = _class.staticFieldId( + r"ACTION_INSTALL_PACKAGE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_INSTALL_PACKAGE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_INSTALL_PACKAGE => - _get_ACTION_INSTALL_PACKAGE().object(const jni.JStringType()); + _id_ACTION_INSTALL_PACKAGE.get(_class, const jni.JStringType()); - static final _get_ACTION_LOCALE_CHANGED = - jniLookup>( - "get_Intent__ACTION_LOCALE_CHANGED") - .asFunction(); + static final _id_ACTION_LOCALE_CHANGED = _class.staticFieldId( + r"ACTION_LOCALE_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_LOCALE_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_LOCALE_CHANGED => - _get_ACTION_LOCALE_CHANGED().object(const jni.JStringType()); + _id_ACTION_LOCALE_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_LOCKED_BOOT_COMPLETED = - jniLookup>( - "get_Intent__ACTION_LOCKED_BOOT_COMPLETED") - .asFunction(); + static final _id_ACTION_LOCKED_BOOT_COMPLETED = _class.staticFieldId( + r"ACTION_LOCKED_BOOT_COMPLETED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_LOCKED_BOOT_COMPLETED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_LOCKED_BOOT_COMPLETED => - _get_ACTION_LOCKED_BOOT_COMPLETED().object(const jni.JStringType()); + _id_ACTION_LOCKED_BOOT_COMPLETED.get(_class, const jni.JStringType()); - static final _get_ACTION_MAIN = - jniLookup>( - "get_Intent__ACTION_MAIN") - .asFunction(); + static final _id_ACTION_MAIN = _class.staticFieldId( + r"ACTION_MAIN", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MAIN /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MAIN => - _get_ACTION_MAIN().object(const jni.JStringType()); + _id_ACTION_MAIN.get(_class, const jni.JStringType()); - static final _get_ACTION_MANAGED_PROFILE_ADDED = - jniLookup>( - "get_Intent__ACTION_MANAGED_PROFILE_ADDED") - .asFunction(); + static final _id_ACTION_MANAGED_PROFILE_ADDED = _class.staticFieldId( + r"ACTION_MANAGED_PROFILE_ADDED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MANAGED_PROFILE_ADDED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MANAGED_PROFILE_ADDED => - _get_ACTION_MANAGED_PROFILE_ADDED().object(const jni.JStringType()); + _id_ACTION_MANAGED_PROFILE_ADDED.get(_class, const jni.JStringType()); - static final _get_ACTION_MANAGED_PROFILE_AVAILABLE = - jniLookup>( - "get_Intent__ACTION_MANAGED_PROFILE_AVAILABLE") - .asFunction(); + static final _id_ACTION_MANAGED_PROFILE_AVAILABLE = _class.staticFieldId( + r"ACTION_MANAGED_PROFILE_AVAILABLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MANAGED_PROFILE_AVAILABLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MANAGED_PROFILE_AVAILABLE => - _get_ACTION_MANAGED_PROFILE_AVAILABLE().object(const jni.JStringType()); + _id_ACTION_MANAGED_PROFILE_AVAILABLE.get(_class, const jni.JStringType()); - static final _get_ACTION_MANAGED_PROFILE_REMOVED = - jniLookup>( - "get_Intent__ACTION_MANAGED_PROFILE_REMOVED") - .asFunction(); + static final _id_ACTION_MANAGED_PROFILE_REMOVED = _class.staticFieldId( + r"ACTION_MANAGED_PROFILE_REMOVED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MANAGED_PROFILE_REMOVED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MANAGED_PROFILE_REMOVED => - _get_ACTION_MANAGED_PROFILE_REMOVED().object(const jni.JStringType()); + _id_ACTION_MANAGED_PROFILE_REMOVED.get(_class, const jni.JStringType()); - static final _get_ACTION_MANAGED_PROFILE_UNAVAILABLE = - jniLookup>( - "get_Intent__ACTION_MANAGED_PROFILE_UNAVAILABLE") - .asFunction(); + static final _id_ACTION_MANAGED_PROFILE_UNAVAILABLE = _class.staticFieldId( + r"ACTION_MANAGED_PROFILE_UNAVAILABLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MANAGED_PROFILE_UNAVAILABLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MANAGED_PROFILE_UNAVAILABLE => - _get_ACTION_MANAGED_PROFILE_UNAVAILABLE().object(const jni.JStringType()); + _id_ACTION_MANAGED_PROFILE_UNAVAILABLE.get( + _class, const jni.JStringType()); - static final _get_ACTION_MANAGED_PROFILE_UNLOCKED = - jniLookup>( - "get_Intent__ACTION_MANAGED_PROFILE_UNLOCKED") - .asFunction(); + static final _id_ACTION_MANAGED_PROFILE_UNLOCKED = _class.staticFieldId( + r"ACTION_MANAGED_PROFILE_UNLOCKED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MANAGED_PROFILE_UNLOCKED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MANAGED_PROFILE_UNLOCKED => - _get_ACTION_MANAGED_PROFILE_UNLOCKED().object(const jni.JStringType()); + _id_ACTION_MANAGED_PROFILE_UNLOCKED.get(_class, const jni.JStringType()); - static final _get_ACTION_MANAGE_NETWORK_USAGE = - jniLookup>( - "get_Intent__ACTION_MANAGE_NETWORK_USAGE") - .asFunction(); + static final _id_ACTION_MANAGE_NETWORK_USAGE = _class.staticFieldId( + r"ACTION_MANAGE_NETWORK_USAGE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MANAGE_NETWORK_USAGE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MANAGE_NETWORK_USAGE => - _get_ACTION_MANAGE_NETWORK_USAGE().object(const jni.JStringType()); + _id_ACTION_MANAGE_NETWORK_USAGE.get(_class, const jni.JStringType()); - static final _get_ACTION_MANAGE_PACKAGE_STORAGE = - jniLookup>( - "get_Intent__ACTION_MANAGE_PACKAGE_STORAGE") - .asFunction(); + static final _id_ACTION_MANAGE_PACKAGE_STORAGE = _class.staticFieldId( + r"ACTION_MANAGE_PACKAGE_STORAGE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MANAGE_PACKAGE_STORAGE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MANAGE_PACKAGE_STORAGE => - _get_ACTION_MANAGE_PACKAGE_STORAGE().object(const jni.JStringType()); + _id_ACTION_MANAGE_PACKAGE_STORAGE.get(_class, const jni.JStringType()); - static final _get_ACTION_MANAGE_UNUSED_APPS = - jniLookup>( - "get_Intent__ACTION_MANAGE_UNUSED_APPS") - .asFunction(); + static final _id_ACTION_MANAGE_UNUSED_APPS = _class.staticFieldId( + r"ACTION_MANAGE_UNUSED_APPS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MANAGE_UNUSED_APPS /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MANAGE_UNUSED_APPS => - _get_ACTION_MANAGE_UNUSED_APPS().object(const jni.JStringType()); + _id_ACTION_MANAGE_UNUSED_APPS.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_BAD_REMOVAL = - jniLookup>( - "get_Intent__ACTION_MEDIA_BAD_REMOVAL") - .asFunction(); + static final _id_ACTION_MEDIA_BAD_REMOVAL = _class.staticFieldId( + r"ACTION_MEDIA_BAD_REMOVAL", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_BAD_REMOVAL /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_BAD_REMOVAL => - _get_ACTION_MEDIA_BAD_REMOVAL().object(const jni.JStringType()); + _id_ACTION_MEDIA_BAD_REMOVAL.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_BUTTON = - jniLookup>( - "get_Intent__ACTION_MEDIA_BUTTON") - .asFunction(); + static final _id_ACTION_MEDIA_BUTTON = _class.staticFieldId( + r"ACTION_MEDIA_BUTTON", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_BUTTON /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_BUTTON => - _get_ACTION_MEDIA_BUTTON().object(const jni.JStringType()); + _id_ACTION_MEDIA_BUTTON.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_CHECKING = - jniLookup>( - "get_Intent__ACTION_MEDIA_CHECKING") - .asFunction(); + static final _id_ACTION_MEDIA_CHECKING = _class.staticFieldId( + r"ACTION_MEDIA_CHECKING", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_CHECKING /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_CHECKING => - _get_ACTION_MEDIA_CHECKING().object(const jni.JStringType()); + _id_ACTION_MEDIA_CHECKING.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_EJECT = - jniLookup>( - "get_Intent__ACTION_MEDIA_EJECT") - .asFunction(); + static final _id_ACTION_MEDIA_EJECT = _class.staticFieldId( + r"ACTION_MEDIA_EJECT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_EJECT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_EJECT => - _get_ACTION_MEDIA_EJECT().object(const jni.JStringType()); + _id_ACTION_MEDIA_EJECT.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_MOUNTED = - jniLookup>( - "get_Intent__ACTION_MEDIA_MOUNTED") - .asFunction(); + static final _id_ACTION_MEDIA_MOUNTED = _class.staticFieldId( + r"ACTION_MEDIA_MOUNTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_MOUNTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_MOUNTED => - _get_ACTION_MEDIA_MOUNTED().object(const jni.JStringType()); + _id_ACTION_MEDIA_MOUNTED.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_NOFS = - jniLookup>( - "get_Intent__ACTION_MEDIA_NOFS") - .asFunction(); + static final _id_ACTION_MEDIA_NOFS = _class.staticFieldId( + r"ACTION_MEDIA_NOFS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_NOFS /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_NOFS => - _get_ACTION_MEDIA_NOFS().object(const jni.JStringType()); + _id_ACTION_MEDIA_NOFS.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_REMOVED = - jniLookup>( - "get_Intent__ACTION_MEDIA_REMOVED") - .asFunction(); + static final _id_ACTION_MEDIA_REMOVED = _class.staticFieldId( + r"ACTION_MEDIA_REMOVED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_REMOVED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_REMOVED => - _get_ACTION_MEDIA_REMOVED().object(const jni.JStringType()); + _id_ACTION_MEDIA_REMOVED.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_SCANNER_FINISHED = - jniLookup>( - "get_Intent__ACTION_MEDIA_SCANNER_FINISHED") - .asFunction(); + static final _id_ACTION_MEDIA_SCANNER_FINISHED = _class.staticFieldId( + r"ACTION_MEDIA_SCANNER_FINISHED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_SCANNER_FINISHED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_SCANNER_FINISHED => - _get_ACTION_MEDIA_SCANNER_FINISHED().object(const jni.JStringType()); + _id_ACTION_MEDIA_SCANNER_FINISHED.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_SCANNER_SCAN_FILE = - jniLookup>( - "get_Intent__ACTION_MEDIA_SCANNER_SCAN_FILE") - .asFunction(); + static final _id_ACTION_MEDIA_SCANNER_SCAN_FILE = _class.staticFieldId( + r"ACTION_MEDIA_SCANNER_SCAN_FILE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_SCANNER_SCAN_FILE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_SCANNER_SCAN_FILE => - _get_ACTION_MEDIA_SCANNER_SCAN_FILE().object(const jni.JStringType()); + _id_ACTION_MEDIA_SCANNER_SCAN_FILE.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_SCANNER_STARTED = - jniLookup>( - "get_Intent__ACTION_MEDIA_SCANNER_STARTED") - .asFunction(); + static final _id_ACTION_MEDIA_SCANNER_STARTED = _class.staticFieldId( + r"ACTION_MEDIA_SCANNER_STARTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_SCANNER_STARTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_SCANNER_STARTED => - _get_ACTION_MEDIA_SCANNER_STARTED().object(const jni.JStringType()); + _id_ACTION_MEDIA_SCANNER_STARTED.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_SHARED = - jniLookup>( - "get_Intent__ACTION_MEDIA_SHARED") - .asFunction(); + static final _id_ACTION_MEDIA_SHARED = _class.staticFieldId( + r"ACTION_MEDIA_SHARED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_SHARED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_SHARED => - _get_ACTION_MEDIA_SHARED().object(const jni.JStringType()); + _id_ACTION_MEDIA_SHARED.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_UNMOUNTABLE = - jniLookup>( - "get_Intent__ACTION_MEDIA_UNMOUNTABLE") - .asFunction(); + static final _id_ACTION_MEDIA_UNMOUNTABLE = _class.staticFieldId( + r"ACTION_MEDIA_UNMOUNTABLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_UNMOUNTABLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_UNMOUNTABLE => - _get_ACTION_MEDIA_UNMOUNTABLE().object(const jni.JStringType()); + _id_ACTION_MEDIA_UNMOUNTABLE.get(_class, const jni.JStringType()); - static final _get_ACTION_MEDIA_UNMOUNTED = - jniLookup>( - "get_Intent__ACTION_MEDIA_UNMOUNTED") - .asFunction(); + static final _id_ACTION_MEDIA_UNMOUNTED = _class.staticFieldId( + r"ACTION_MEDIA_UNMOUNTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MEDIA_UNMOUNTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MEDIA_UNMOUNTED => - _get_ACTION_MEDIA_UNMOUNTED().object(const jni.JStringType()); + _id_ACTION_MEDIA_UNMOUNTED.get(_class, const jni.JStringType()); - static final _get_ACTION_MY_PACKAGE_REPLACED = - jniLookup>( - "get_Intent__ACTION_MY_PACKAGE_REPLACED") - .asFunction(); + static final _id_ACTION_MY_PACKAGE_REPLACED = _class.staticFieldId( + r"ACTION_MY_PACKAGE_REPLACED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MY_PACKAGE_REPLACED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MY_PACKAGE_REPLACED => - _get_ACTION_MY_PACKAGE_REPLACED().object(const jni.JStringType()); + _id_ACTION_MY_PACKAGE_REPLACED.get(_class, const jni.JStringType()); - static final _get_ACTION_MY_PACKAGE_SUSPENDED = - jniLookup>( - "get_Intent__ACTION_MY_PACKAGE_SUSPENDED") - .asFunction(); + static final _id_ACTION_MY_PACKAGE_SUSPENDED = _class.staticFieldId( + r"ACTION_MY_PACKAGE_SUSPENDED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MY_PACKAGE_SUSPENDED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MY_PACKAGE_SUSPENDED => - _get_ACTION_MY_PACKAGE_SUSPENDED().object(const jni.JStringType()); + _id_ACTION_MY_PACKAGE_SUSPENDED.get(_class, const jni.JStringType()); - static final _get_ACTION_MY_PACKAGE_UNSUSPENDED = - jniLookup>( - "get_Intent__ACTION_MY_PACKAGE_UNSUSPENDED") - .asFunction(); + static final _id_ACTION_MY_PACKAGE_UNSUSPENDED = _class.staticFieldId( + r"ACTION_MY_PACKAGE_UNSUSPENDED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_MY_PACKAGE_UNSUSPENDED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_MY_PACKAGE_UNSUSPENDED => - _get_ACTION_MY_PACKAGE_UNSUSPENDED().object(const jni.JStringType()); + _id_ACTION_MY_PACKAGE_UNSUSPENDED.get(_class, const jni.JStringType()); - static final _get_ACTION_NEW_OUTGOING_CALL = - jniLookup>( - "get_Intent__ACTION_NEW_OUTGOING_CALL") - .asFunction(); + static final _id_ACTION_NEW_OUTGOING_CALL = _class.staticFieldId( + r"ACTION_NEW_OUTGOING_CALL", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_NEW_OUTGOING_CALL /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_NEW_OUTGOING_CALL => - _get_ACTION_NEW_OUTGOING_CALL().object(const jni.JStringType()); + _id_ACTION_NEW_OUTGOING_CALL.get(_class, const jni.JStringType()); - static final _get_ACTION_OPEN_DOCUMENT = - jniLookup>( - "get_Intent__ACTION_OPEN_DOCUMENT") - .asFunction(); + static final _id_ACTION_OPEN_DOCUMENT = _class.staticFieldId( + r"ACTION_OPEN_DOCUMENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_OPEN_DOCUMENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_OPEN_DOCUMENT => - _get_ACTION_OPEN_DOCUMENT().object(const jni.JStringType()); + _id_ACTION_OPEN_DOCUMENT.get(_class, const jni.JStringType()); - static final _get_ACTION_OPEN_DOCUMENT_TREE = - jniLookup>( - "get_Intent__ACTION_OPEN_DOCUMENT_TREE") - .asFunction(); + static final _id_ACTION_OPEN_DOCUMENT_TREE = _class.staticFieldId( + r"ACTION_OPEN_DOCUMENT_TREE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_OPEN_DOCUMENT_TREE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_OPEN_DOCUMENT_TREE => - _get_ACTION_OPEN_DOCUMENT_TREE().object(const jni.JStringType()); + _id_ACTION_OPEN_DOCUMENT_TREE.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGES_SUSPENDED = - jniLookup>( - "get_Intent__ACTION_PACKAGES_SUSPENDED") - .asFunction(); + static final _id_ACTION_PACKAGES_SUSPENDED = _class.staticFieldId( + r"ACTION_PACKAGES_SUSPENDED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGES_SUSPENDED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGES_SUSPENDED => - _get_ACTION_PACKAGES_SUSPENDED().object(const jni.JStringType()); + _id_ACTION_PACKAGES_SUSPENDED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGES_UNSUSPENDED = - jniLookup>( - "get_Intent__ACTION_PACKAGES_UNSUSPENDED") - .asFunction(); + static final _id_ACTION_PACKAGES_UNSUSPENDED = _class.staticFieldId( + r"ACTION_PACKAGES_UNSUSPENDED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGES_UNSUSPENDED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGES_UNSUSPENDED => - _get_ACTION_PACKAGES_UNSUSPENDED().object(const jni.JStringType()); + _id_ACTION_PACKAGES_UNSUSPENDED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_ADDED = - jniLookup>( - "get_Intent__ACTION_PACKAGE_ADDED") - .asFunction(); + static final _id_ACTION_PACKAGE_ADDED = _class.staticFieldId( + r"ACTION_PACKAGE_ADDED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_ADDED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_ADDED => - _get_ACTION_PACKAGE_ADDED().object(const jni.JStringType()); + _id_ACTION_PACKAGE_ADDED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_CHANGED = - jniLookup>( - "get_Intent__ACTION_PACKAGE_CHANGED") - .asFunction(); + static final _id_ACTION_PACKAGE_CHANGED = _class.staticFieldId( + r"ACTION_PACKAGE_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_CHANGED => - _get_ACTION_PACKAGE_CHANGED().object(const jni.JStringType()); + _id_ACTION_PACKAGE_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_DATA_CLEARED = - jniLookup>( - "get_Intent__ACTION_PACKAGE_DATA_CLEARED") - .asFunction(); + static final _id_ACTION_PACKAGE_DATA_CLEARED = _class.staticFieldId( + r"ACTION_PACKAGE_DATA_CLEARED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_DATA_CLEARED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_DATA_CLEARED => - _get_ACTION_PACKAGE_DATA_CLEARED().object(const jni.JStringType()); + _id_ACTION_PACKAGE_DATA_CLEARED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_FIRST_LAUNCH = - jniLookup>( - "get_Intent__ACTION_PACKAGE_FIRST_LAUNCH") - .asFunction(); + static final _id_ACTION_PACKAGE_FIRST_LAUNCH = _class.staticFieldId( + r"ACTION_PACKAGE_FIRST_LAUNCH", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_FIRST_LAUNCH /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_FIRST_LAUNCH => - _get_ACTION_PACKAGE_FIRST_LAUNCH().object(const jni.JStringType()); + _id_ACTION_PACKAGE_FIRST_LAUNCH.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_FULLY_REMOVED = - jniLookup>( - "get_Intent__ACTION_PACKAGE_FULLY_REMOVED") - .asFunction(); + static final _id_ACTION_PACKAGE_FULLY_REMOVED = _class.staticFieldId( + r"ACTION_PACKAGE_FULLY_REMOVED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_FULLY_REMOVED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_FULLY_REMOVED => - _get_ACTION_PACKAGE_FULLY_REMOVED().object(const jni.JStringType()); + _id_ACTION_PACKAGE_FULLY_REMOVED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_INSTALL = - jniLookup>( - "get_Intent__ACTION_PACKAGE_INSTALL") - .asFunction(); + static final _id_ACTION_PACKAGE_INSTALL = _class.staticFieldId( + r"ACTION_PACKAGE_INSTALL", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_INSTALL /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_INSTALL => - _get_ACTION_PACKAGE_INSTALL().object(const jni.JStringType()); + _id_ACTION_PACKAGE_INSTALL.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_NEEDS_VERIFICATION = - jniLookup>( - "get_Intent__ACTION_PACKAGE_NEEDS_VERIFICATION") - .asFunction(); + static final _id_ACTION_PACKAGE_NEEDS_VERIFICATION = _class.staticFieldId( + r"ACTION_PACKAGE_NEEDS_VERIFICATION", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_NEEDS_VERIFICATION /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_NEEDS_VERIFICATION => - _get_ACTION_PACKAGE_NEEDS_VERIFICATION().object(const jni.JStringType()); + _id_ACTION_PACKAGE_NEEDS_VERIFICATION.get( + _class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_REMOVED = - jniLookup>( - "get_Intent__ACTION_PACKAGE_REMOVED") - .asFunction(); + static final _id_ACTION_PACKAGE_REMOVED = _class.staticFieldId( + r"ACTION_PACKAGE_REMOVED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_REMOVED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_REMOVED => - _get_ACTION_PACKAGE_REMOVED().object(const jni.JStringType()); + _id_ACTION_PACKAGE_REMOVED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_REPLACED = - jniLookup>( - "get_Intent__ACTION_PACKAGE_REPLACED") - .asFunction(); + static final _id_ACTION_PACKAGE_REPLACED = _class.staticFieldId( + r"ACTION_PACKAGE_REPLACED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_REPLACED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_REPLACED => - _get_ACTION_PACKAGE_REPLACED().object(const jni.JStringType()); + _id_ACTION_PACKAGE_REPLACED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_RESTARTED = - jniLookup>( - "get_Intent__ACTION_PACKAGE_RESTARTED") - .asFunction(); + static final _id_ACTION_PACKAGE_RESTARTED = _class.staticFieldId( + r"ACTION_PACKAGE_RESTARTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_RESTARTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_RESTARTED => - _get_ACTION_PACKAGE_RESTARTED().object(const jni.JStringType()); + _id_ACTION_PACKAGE_RESTARTED.get(_class, const jni.JStringType()); - static final _get_ACTION_PACKAGE_VERIFIED = - jniLookup>( - "get_Intent__ACTION_PACKAGE_VERIFIED") - .asFunction(); + static final _id_ACTION_PACKAGE_VERIFIED = _class.staticFieldId( + r"ACTION_PACKAGE_VERIFIED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PACKAGE_VERIFIED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PACKAGE_VERIFIED => - _get_ACTION_PACKAGE_VERIFIED().object(const jni.JStringType()); + _id_ACTION_PACKAGE_VERIFIED.get(_class, const jni.JStringType()); - static final _get_ACTION_PASTE = - jniLookup>( - "get_Intent__ACTION_PASTE") - .asFunction(); + static final _id_ACTION_PASTE = _class.staticFieldId( + r"ACTION_PASTE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PASTE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PASTE => - _get_ACTION_PASTE().object(const jni.JStringType()); + _id_ACTION_PASTE.get(_class, const jni.JStringType()); - static final _get_ACTION_PICK = - jniLookup>( - "get_Intent__ACTION_PICK") - .asFunction(); + static final _id_ACTION_PICK = _class.staticFieldId( + r"ACTION_PICK", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PICK /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PICK => - _get_ACTION_PICK().object(const jni.JStringType()); + _id_ACTION_PICK.get(_class, const jni.JStringType()); - static final _get_ACTION_PICK_ACTIVITY = - jniLookup>( - "get_Intent__ACTION_PICK_ACTIVITY") - .asFunction(); + static final _id_ACTION_PICK_ACTIVITY = _class.staticFieldId( + r"ACTION_PICK_ACTIVITY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PICK_ACTIVITY /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PICK_ACTIVITY => - _get_ACTION_PICK_ACTIVITY().object(const jni.JStringType()); + _id_ACTION_PICK_ACTIVITY.get(_class, const jni.JStringType()); - static final _get_ACTION_POWER_CONNECTED = - jniLookup>( - "get_Intent__ACTION_POWER_CONNECTED") - .asFunction(); + static final _id_ACTION_POWER_CONNECTED = _class.staticFieldId( + r"ACTION_POWER_CONNECTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_POWER_CONNECTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_POWER_CONNECTED => - _get_ACTION_POWER_CONNECTED().object(const jni.JStringType()); + _id_ACTION_POWER_CONNECTED.get(_class, const jni.JStringType()); - static final _get_ACTION_POWER_DISCONNECTED = - jniLookup>( - "get_Intent__ACTION_POWER_DISCONNECTED") - .asFunction(); + static final _id_ACTION_POWER_DISCONNECTED = _class.staticFieldId( + r"ACTION_POWER_DISCONNECTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_POWER_DISCONNECTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_POWER_DISCONNECTED => - _get_ACTION_POWER_DISCONNECTED().object(const jni.JStringType()); + _id_ACTION_POWER_DISCONNECTED.get(_class, const jni.JStringType()); - static final _get_ACTION_POWER_USAGE_SUMMARY = - jniLookup>( - "get_Intent__ACTION_POWER_USAGE_SUMMARY") - .asFunction(); + static final _id_ACTION_POWER_USAGE_SUMMARY = _class.staticFieldId( + r"ACTION_POWER_USAGE_SUMMARY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_POWER_USAGE_SUMMARY /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_POWER_USAGE_SUMMARY => - _get_ACTION_POWER_USAGE_SUMMARY().object(const jni.JStringType()); + _id_ACTION_POWER_USAGE_SUMMARY.get(_class, const jni.JStringType()); - static final _get_ACTION_PROCESS_TEXT = - jniLookup>( - "get_Intent__ACTION_PROCESS_TEXT") - .asFunction(); + static final _id_ACTION_PROCESS_TEXT = _class.staticFieldId( + r"ACTION_PROCESS_TEXT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PROCESS_TEXT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PROCESS_TEXT => - _get_ACTION_PROCESS_TEXT().object(const jni.JStringType()); + _id_ACTION_PROCESS_TEXT.get(_class, const jni.JStringType()); - static final _get_ACTION_PROFILE_ACCESSIBLE = - jniLookup>( - "get_Intent__ACTION_PROFILE_ACCESSIBLE") - .asFunction(); + static final _id_ACTION_PROFILE_ACCESSIBLE = _class.staticFieldId( + r"ACTION_PROFILE_ACCESSIBLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PROFILE_ACCESSIBLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PROFILE_ACCESSIBLE => - _get_ACTION_PROFILE_ACCESSIBLE().object(const jni.JStringType()); + _id_ACTION_PROFILE_ACCESSIBLE.get(_class, const jni.JStringType()); - static final _get_ACTION_PROFILE_INACCESSIBLE = - jniLookup>( - "get_Intent__ACTION_PROFILE_INACCESSIBLE") - .asFunction(); + static final _id_ACTION_PROFILE_INACCESSIBLE = _class.staticFieldId( + r"ACTION_PROFILE_INACCESSIBLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PROFILE_INACCESSIBLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PROFILE_INACCESSIBLE => - _get_ACTION_PROFILE_INACCESSIBLE().object(const jni.JStringType()); + _id_ACTION_PROFILE_INACCESSIBLE.get(_class, const jni.JStringType()); - static final _get_ACTION_PROVIDER_CHANGED = - jniLookup>( - "get_Intent__ACTION_PROVIDER_CHANGED") - .asFunction(); + static final _id_ACTION_PROVIDER_CHANGED = _class.staticFieldId( + r"ACTION_PROVIDER_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_PROVIDER_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_PROVIDER_CHANGED => - _get_ACTION_PROVIDER_CHANGED().object(const jni.JStringType()); + _id_ACTION_PROVIDER_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_QUICK_CLOCK = - jniLookup>( - "get_Intent__ACTION_QUICK_CLOCK") - .asFunction(); + static final _id_ACTION_QUICK_CLOCK = _class.staticFieldId( + r"ACTION_QUICK_CLOCK", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_QUICK_CLOCK /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_QUICK_CLOCK => - _get_ACTION_QUICK_CLOCK().object(const jni.JStringType()); + _id_ACTION_QUICK_CLOCK.get(_class, const jni.JStringType()); - static final _get_ACTION_QUICK_VIEW = - jniLookup>( - "get_Intent__ACTION_QUICK_VIEW") - .asFunction(); + static final _id_ACTION_QUICK_VIEW = _class.staticFieldId( + r"ACTION_QUICK_VIEW", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_QUICK_VIEW /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_QUICK_VIEW => - _get_ACTION_QUICK_VIEW().object(const jni.JStringType()); + _id_ACTION_QUICK_VIEW.get(_class, const jni.JStringType()); - static final _get_ACTION_REBOOT = - jniLookup>( - "get_Intent__ACTION_REBOOT") - .asFunction(); + static final _id_ACTION_REBOOT = _class.staticFieldId( + r"ACTION_REBOOT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_REBOOT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_REBOOT => - _get_ACTION_REBOOT().object(const jni.JStringType()); + _id_ACTION_REBOOT.get(_class, const jni.JStringType()); - static final _get_ACTION_RUN = - jniLookup>( - "get_Intent__ACTION_RUN") - .asFunction(); + static final _id_ACTION_RUN = _class.staticFieldId( + r"ACTION_RUN", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_RUN /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_RUN => - _get_ACTION_RUN().object(const jni.JStringType()); + _id_ACTION_RUN.get(_class, const jni.JStringType()); - static final _get_ACTION_SAFETY_CENTER = - jniLookup>( - "get_Intent__ACTION_SAFETY_CENTER") - .asFunction(); + static final _id_ACTION_SAFETY_CENTER = _class.staticFieldId( + r"ACTION_SAFETY_CENTER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SAFETY_CENTER /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SAFETY_CENTER => - _get_ACTION_SAFETY_CENTER().object(const jni.JStringType()); + _id_ACTION_SAFETY_CENTER.get(_class, const jni.JStringType()); - static final _get_ACTION_SCREEN_OFF = - jniLookup>( - "get_Intent__ACTION_SCREEN_OFF") - .asFunction(); + static final _id_ACTION_SCREEN_OFF = _class.staticFieldId( + r"ACTION_SCREEN_OFF", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SCREEN_OFF /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SCREEN_OFF => - _get_ACTION_SCREEN_OFF().object(const jni.JStringType()); + _id_ACTION_SCREEN_OFF.get(_class, const jni.JStringType()); - static final _get_ACTION_SCREEN_ON = - jniLookup>( - "get_Intent__ACTION_SCREEN_ON") - .asFunction(); + static final _id_ACTION_SCREEN_ON = _class.staticFieldId( + r"ACTION_SCREEN_ON", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SCREEN_ON /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SCREEN_ON => - _get_ACTION_SCREEN_ON().object(const jni.JStringType()); + _id_ACTION_SCREEN_ON.get(_class, const jni.JStringType()); - static final _get_ACTION_SEARCH = - jniLookup>( - "get_Intent__ACTION_SEARCH") - .asFunction(); + static final _id_ACTION_SEARCH = _class.staticFieldId( + r"ACTION_SEARCH", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SEARCH /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SEARCH => - _get_ACTION_SEARCH().object(const jni.JStringType()); + _id_ACTION_SEARCH.get(_class, const jni.JStringType()); - static final _get_ACTION_SEARCH_LONG_PRESS = - jniLookup>( - "get_Intent__ACTION_SEARCH_LONG_PRESS") - .asFunction(); + static final _id_ACTION_SEARCH_LONG_PRESS = _class.staticFieldId( + r"ACTION_SEARCH_LONG_PRESS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SEARCH_LONG_PRESS /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SEARCH_LONG_PRESS => - _get_ACTION_SEARCH_LONG_PRESS().object(const jni.JStringType()); + _id_ACTION_SEARCH_LONG_PRESS.get(_class, const jni.JStringType()); - static final _get_ACTION_SEND = - jniLookup>( - "get_Intent__ACTION_SEND") - .asFunction(); + static final _id_ACTION_SEND = _class.staticFieldId( + r"ACTION_SEND", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SEND /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SEND => - _get_ACTION_SEND().object(const jni.JStringType()); + _id_ACTION_SEND.get(_class, const jni.JStringType()); - static final _get_ACTION_SENDTO = - jniLookup>( - "get_Intent__ACTION_SENDTO") - .asFunction(); + static final _id_ACTION_SENDTO = _class.staticFieldId( + r"ACTION_SENDTO", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SENDTO /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SENDTO => - _get_ACTION_SENDTO().object(const jni.JStringType()); + _id_ACTION_SENDTO.get(_class, const jni.JStringType()); - static final _get_ACTION_SEND_MULTIPLE = - jniLookup>( - "get_Intent__ACTION_SEND_MULTIPLE") - .asFunction(); + static final _id_ACTION_SEND_MULTIPLE = _class.staticFieldId( + r"ACTION_SEND_MULTIPLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SEND_MULTIPLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SEND_MULTIPLE => - _get_ACTION_SEND_MULTIPLE().object(const jni.JStringType()); + _id_ACTION_SEND_MULTIPLE.get(_class, const jni.JStringType()); - static final _get_ACTION_SET_WALLPAPER = - jniLookup>( - "get_Intent__ACTION_SET_WALLPAPER") - .asFunction(); + static final _id_ACTION_SET_WALLPAPER = _class.staticFieldId( + r"ACTION_SET_WALLPAPER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SET_WALLPAPER /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SET_WALLPAPER => - _get_ACTION_SET_WALLPAPER().object(const jni.JStringType()); + _id_ACTION_SET_WALLPAPER.get(_class, const jni.JStringType()); - static final _get_ACTION_SHOW_APP_INFO = - jniLookup>( - "get_Intent__ACTION_SHOW_APP_INFO") - .asFunction(); + static final _id_ACTION_SHOW_APP_INFO = _class.staticFieldId( + r"ACTION_SHOW_APP_INFO", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SHOW_APP_INFO /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SHOW_APP_INFO => - _get_ACTION_SHOW_APP_INFO().object(const jni.JStringType()); + _id_ACTION_SHOW_APP_INFO.get(_class, const jni.JStringType()); - static final _get_ACTION_SHOW_WORK_APPS = - jniLookup>( - "get_Intent__ACTION_SHOW_WORK_APPS") - .asFunction(); + static final _id_ACTION_SHOW_WORK_APPS = _class.staticFieldId( + r"ACTION_SHOW_WORK_APPS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SHOW_WORK_APPS /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SHOW_WORK_APPS => - _get_ACTION_SHOW_WORK_APPS().object(const jni.JStringType()); + _id_ACTION_SHOW_WORK_APPS.get(_class, const jni.JStringType()); - static final _get_ACTION_SHUTDOWN = - jniLookup>( - "get_Intent__ACTION_SHUTDOWN") - .asFunction(); + static final _id_ACTION_SHUTDOWN = _class.staticFieldId( + r"ACTION_SHUTDOWN", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SHUTDOWN /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SHUTDOWN => - _get_ACTION_SHUTDOWN().object(const jni.JStringType()); + _id_ACTION_SHUTDOWN.get(_class, const jni.JStringType()); - static final _get_ACTION_SYNC = - jniLookup>( - "get_Intent__ACTION_SYNC") - .asFunction(); + static final _id_ACTION_SYNC = _class.staticFieldId( + r"ACTION_SYNC", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SYNC /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SYNC => - _get_ACTION_SYNC().object(const jni.JStringType()); + _id_ACTION_SYNC.get(_class, const jni.JStringType()); - static final _get_ACTION_SYSTEM_TUTORIAL = - jniLookup>( - "get_Intent__ACTION_SYSTEM_TUTORIAL") - .asFunction(); + static final _id_ACTION_SYSTEM_TUTORIAL = _class.staticFieldId( + r"ACTION_SYSTEM_TUTORIAL", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_SYSTEM_TUTORIAL /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_SYSTEM_TUTORIAL => - _get_ACTION_SYSTEM_TUTORIAL().object(const jni.JStringType()); + _id_ACTION_SYSTEM_TUTORIAL.get(_class, const jni.JStringType()); - static final _get_ACTION_TIMEZONE_CHANGED = - jniLookup>( - "get_Intent__ACTION_TIMEZONE_CHANGED") - .asFunction(); + static final _id_ACTION_TIMEZONE_CHANGED = _class.staticFieldId( + r"ACTION_TIMEZONE_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_TIMEZONE_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_TIMEZONE_CHANGED => - _get_ACTION_TIMEZONE_CHANGED().object(const jni.JStringType()); + _id_ACTION_TIMEZONE_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_TIME_CHANGED = - jniLookup>( - "get_Intent__ACTION_TIME_CHANGED") - .asFunction(); + static final _id_ACTION_TIME_CHANGED = _class.staticFieldId( + r"ACTION_TIME_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_TIME_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_TIME_CHANGED => - _get_ACTION_TIME_CHANGED().object(const jni.JStringType()); + _id_ACTION_TIME_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_TIME_TICK = - jniLookup>( - "get_Intent__ACTION_TIME_TICK") - .asFunction(); + static final _id_ACTION_TIME_TICK = _class.staticFieldId( + r"ACTION_TIME_TICK", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_TIME_TICK /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_TIME_TICK => - _get_ACTION_TIME_TICK().object(const jni.JStringType()); + _id_ACTION_TIME_TICK.get(_class, const jni.JStringType()); - static final _get_ACTION_TRANSLATE = - jniLookup>( - "get_Intent__ACTION_TRANSLATE") - .asFunction(); + static final _id_ACTION_TRANSLATE = _class.staticFieldId( + r"ACTION_TRANSLATE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_TRANSLATE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_TRANSLATE => - _get_ACTION_TRANSLATE().object(const jni.JStringType()); + _id_ACTION_TRANSLATE.get(_class, const jni.JStringType()); - static final _get_ACTION_UID_REMOVED = - jniLookup>( - "get_Intent__ACTION_UID_REMOVED") - .asFunction(); + static final _id_ACTION_UID_REMOVED = _class.staticFieldId( + r"ACTION_UID_REMOVED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_UID_REMOVED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_UID_REMOVED => - _get_ACTION_UID_REMOVED().object(const jni.JStringType()); + _id_ACTION_UID_REMOVED.get(_class, const jni.JStringType()); - static final _get_ACTION_UMS_CONNECTED = - jniLookup>( - "get_Intent__ACTION_UMS_CONNECTED") - .asFunction(); + static final _id_ACTION_UMS_CONNECTED = _class.staticFieldId( + r"ACTION_UMS_CONNECTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_UMS_CONNECTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_UMS_CONNECTED => - _get_ACTION_UMS_CONNECTED().object(const jni.JStringType()); + _id_ACTION_UMS_CONNECTED.get(_class, const jni.JStringType()); - static final _get_ACTION_UMS_DISCONNECTED = - jniLookup>( - "get_Intent__ACTION_UMS_DISCONNECTED") - .asFunction(); + static final _id_ACTION_UMS_DISCONNECTED = _class.staticFieldId( + r"ACTION_UMS_DISCONNECTED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_UMS_DISCONNECTED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_UMS_DISCONNECTED => - _get_ACTION_UMS_DISCONNECTED().object(const jni.JStringType()); + _id_ACTION_UMS_DISCONNECTED.get(_class, const jni.JStringType()); - static final _get_ACTION_UNINSTALL_PACKAGE = - jniLookup>( - "get_Intent__ACTION_UNINSTALL_PACKAGE") - .asFunction(); + static final _id_ACTION_UNINSTALL_PACKAGE = _class.staticFieldId( + r"ACTION_UNINSTALL_PACKAGE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_UNINSTALL_PACKAGE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_UNINSTALL_PACKAGE => - _get_ACTION_UNINSTALL_PACKAGE().object(const jni.JStringType()); + _id_ACTION_UNINSTALL_PACKAGE.get(_class, const jni.JStringType()); - static final _get_ACTION_USER_BACKGROUND = - jniLookup>( - "get_Intent__ACTION_USER_BACKGROUND") - .asFunction(); + static final _id_ACTION_USER_BACKGROUND = _class.staticFieldId( + r"ACTION_USER_BACKGROUND", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_USER_BACKGROUND /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_USER_BACKGROUND => - _get_ACTION_USER_BACKGROUND().object(const jni.JStringType()); + _id_ACTION_USER_BACKGROUND.get(_class, const jni.JStringType()); - static final _get_ACTION_USER_FOREGROUND = - jniLookup>( - "get_Intent__ACTION_USER_FOREGROUND") - .asFunction(); + static final _id_ACTION_USER_FOREGROUND = _class.staticFieldId( + r"ACTION_USER_FOREGROUND", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_USER_FOREGROUND /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_USER_FOREGROUND => - _get_ACTION_USER_FOREGROUND().object(const jni.JStringType()); + _id_ACTION_USER_FOREGROUND.get(_class, const jni.JStringType()); - static final _get_ACTION_USER_INITIALIZE = - jniLookup>( - "get_Intent__ACTION_USER_INITIALIZE") - .asFunction(); + static final _id_ACTION_USER_INITIALIZE = _class.staticFieldId( + r"ACTION_USER_INITIALIZE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_USER_INITIALIZE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_USER_INITIALIZE => - _get_ACTION_USER_INITIALIZE().object(const jni.JStringType()); + _id_ACTION_USER_INITIALIZE.get(_class, const jni.JStringType()); - static final _get_ACTION_USER_PRESENT = - jniLookup>( - "get_Intent__ACTION_USER_PRESENT") - .asFunction(); + static final _id_ACTION_USER_PRESENT = _class.staticFieldId( + r"ACTION_USER_PRESENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_USER_PRESENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_USER_PRESENT => - _get_ACTION_USER_PRESENT().object(const jni.JStringType()); + _id_ACTION_USER_PRESENT.get(_class, const jni.JStringType()); - static final _get_ACTION_USER_UNLOCKED = - jniLookup>( - "get_Intent__ACTION_USER_UNLOCKED") - .asFunction(); + static final _id_ACTION_USER_UNLOCKED = _class.staticFieldId( + r"ACTION_USER_UNLOCKED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_USER_UNLOCKED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_USER_UNLOCKED => - _get_ACTION_USER_UNLOCKED().object(const jni.JStringType()); + _id_ACTION_USER_UNLOCKED.get(_class, const jni.JStringType()); - static final _get_ACTION_VIEW = - jniLookup>( - "get_Intent__ACTION_VIEW") - .asFunction(); + static final _id_ACTION_VIEW = _class.staticFieldId( + r"ACTION_VIEW", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_VIEW /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_VIEW => - _get_ACTION_VIEW().object(const jni.JStringType()); + _id_ACTION_VIEW.get(_class, const jni.JStringType()); - static final _get_ACTION_VIEW_LOCUS = - jniLookup>( - "get_Intent__ACTION_VIEW_LOCUS") - .asFunction(); + static final _id_ACTION_VIEW_LOCUS = _class.staticFieldId( + r"ACTION_VIEW_LOCUS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_VIEW_LOCUS /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_VIEW_LOCUS => - _get_ACTION_VIEW_LOCUS().object(const jni.JStringType()); + _id_ACTION_VIEW_LOCUS.get(_class, const jni.JStringType()); - static final _get_ACTION_VIEW_PERMISSION_USAGE = - jniLookup>( - "get_Intent__ACTION_VIEW_PERMISSION_USAGE") - .asFunction(); + static final _id_ACTION_VIEW_PERMISSION_USAGE = _class.staticFieldId( + r"ACTION_VIEW_PERMISSION_USAGE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_VIEW_PERMISSION_USAGE /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_VIEW_PERMISSION_USAGE => - _get_ACTION_VIEW_PERMISSION_USAGE().object(const jni.JStringType()); + _id_ACTION_VIEW_PERMISSION_USAGE.get(_class, const jni.JStringType()); - static final _get_ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD = - jniLookup>( - "get_Intent__ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD") - .asFunction(); + static final _id_ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD = + _class.staticFieldId( + r"ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD => - _get_ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD() - .object(const jni.JStringType()); + _id_ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD.get( + _class, const jni.JStringType()); - static final _get_ACTION_VOICE_COMMAND = - jniLookup>( - "get_Intent__ACTION_VOICE_COMMAND") - .asFunction(); + static final _id_ACTION_VOICE_COMMAND = _class.staticFieldId( + r"ACTION_VOICE_COMMAND", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_VOICE_COMMAND /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_VOICE_COMMAND => - _get_ACTION_VOICE_COMMAND().object(const jni.JStringType()); + _id_ACTION_VOICE_COMMAND.get(_class, const jni.JStringType()); - static final _get_ACTION_WALLPAPER_CHANGED = - jniLookup>( - "get_Intent__ACTION_WALLPAPER_CHANGED") - .asFunction(); + static final _id_ACTION_WALLPAPER_CHANGED = _class.staticFieldId( + r"ACTION_WALLPAPER_CHANGED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_WALLPAPER_CHANGED /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_WALLPAPER_CHANGED => - _get_ACTION_WALLPAPER_CHANGED().object(const jni.JStringType()); + _id_ACTION_WALLPAPER_CHANGED.get(_class, const jni.JStringType()); - static final _get_ACTION_WEB_SEARCH = - jniLookup>( - "get_Intent__ACTION_WEB_SEARCH") - .asFunction(); + static final _id_ACTION_WEB_SEARCH = _class.staticFieldId( + r"ACTION_WEB_SEARCH", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String ACTION_WEB_SEARCH /// The returned object must be released after use, by calling the [release] method. static jni.JString get ACTION_WEB_SEARCH => - _get_ACTION_WEB_SEARCH().object(const jni.JStringType()); + _id_ACTION_WEB_SEARCH.get(_class, const jni.JStringType()); - static final _get_CATEGORY_ACCESSIBILITY_SHORTCUT_TARGET = - jniLookup>( - "get_Intent__CATEGORY_ACCESSIBILITY_SHORTCUT_TARGET") - .asFunction(); + static final _id_CATEGORY_ACCESSIBILITY_SHORTCUT_TARGET = + _class.staticFieldId( + r"CATEGORY_ACCESSIBILITY_SHORTCUT_TARGET", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_ACCESSIBILITY_SHORTCUT_TARGET /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_ACCESSIBILITY_SHORTCUT_TARGET => - _get_CATEGORY_ACCESSIBILITY_SHORTCUT_TARGET() - .object(const jni.JStringType()); + _id_CATEGORY_ACCESSIBILITY_SHORTCUT_TARGET.get( + _class, const jni.JStringType()); - static final _get_CATEGORY_ALTERNATIVE = - jniLookup>( - "get_Intent__CATEGORY_ALTERNATIVE") - .asFunction(); + static final _id_CATEGORY_ALTERNATIVE = _class.staticFieldId( + r"CATEGORY_ALTERNATIVE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_ALTERNATIVE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_ALTERNATIVE => - _get_CATEGORY_ALTERNATIVE().object(const jni.JStringType()); + _id_CATEGORY_ALTERNATIVE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_BROWSER = - jniLookup>( - "get_Intent__CATEGORY_APP_BROWSER") - .asFunction(); + static final _id_CATEGORY_APP_BROWSER = _class.staticFieldId( + r"CATEGORY_APP_BROWSER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_BROWSER /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_BROWSER => - _get_CATEGORY_APP_BROWSER().object(const jni.JStringType()); + _id_CATEGORY_APP_BROWSER.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_CALCULATOR = - jniLookup>( - "get_Intent__CATEGORY_APP_CALCULATOR") - .asFunction(); + static final _id_CATEGORY_APP_CALCULATOR = _class.staticFieldId( + r"CATEGORY_APP_CALCULATOR", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_CALCULATOR /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_CALCULATOR => - _get_CATEGORY_APP_CALCULATOR().object(const jni.JStringType()); + _id_CATEGORY_APP_CALCULATOR.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_CALENDAR = - jniLookup>( - "get_Intent__CATEGORY_APP_CALENDAR") - .asFunction(); + static final _id_CATEGORY_APP_CALENDAR = _class.staticFieldId( + r"CATEGORY_APP_CALENDAR", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_CALENDAR /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_CALENDAR => - _get_CATEGORY_APP_CALENDAR().object(const jni.JStringType()); + _id_CATEGORY_APP_CALENDAR.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_CONTACTS = - jniLookup>( - "get_Intent__CATEGORY_APP_CONTACTS") - .asFunction(); + static final _id_CATEGORY_APP_CONTACTS = _class.staticFieldId( + r"CATEGORY_APP_CONTACTS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_CONTACTS /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_CONTACTS => - _get_CATEGORY_APP_CONTACTS().object(const jni.JStringType()); + _id_CATEGORY_APP_CONTACTS.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_EMAIL = - jniLookup>( - "get_Intent__CATEGORY_APP_EMAIL") - .asFunction(); + static final _id_CATEGORY_APP_EMAIL = _class.staticFieldId( + r"CATEGORY_APP_EMAIL", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_EMAIL /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_EMAIL => - _get_CATEGORY_APP_EMAIL().object(const jni.JStringType()); + _id_CATEGORY_APP_EMAIL.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_FILES = - jniLookup>( - "get_Intent__CATEGORY_APP_FILES") - .asFunction(); + static final _id_CATEGORY_APP_FILES = _class.staticFieldId( + r"CATEGORY_APP_FILES", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_FILES /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_FILES => - _get_CATEGORY_APP_FILES().object(const jni.JStringType()); + _id_CATEGORY_APP_FILES.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_FITNESS = - jniLookup>( - "get_Intent__CATEGORY_APP_FITNESS") - .asFunction(); + static final _id_CATEGORY_APP_FITNESS = _class.staticFieldId( + r"CATEGORY_APP_FITNESS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_FITNESS /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_FITNESS => - _get_CATEGORY_APP_FITNESS().object(const jni.JStringType()); + _id_CATEGORY_APP_FITNESS.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_GALLERY = - jniLookup>( - "get_Intent__CATEGORY_APP_GALLERY") - .asFunction(); + static final _id_CATEGORY_APP_GALLERY = _class.staticFieldId( + r"CATEGORY_APP_GALLERY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_GALLERY /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_GALLERY => - _get_CATEGORY_APP_GALLERY().object(const jni.JStringType()); + _id_CATEGORY_APP_GALLERY.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_MAPS = - jniLookup>( - "get_Intent__CATEGORY_APP_MAPS") - .asFunction(); + static final _id_CATEGORY_APP_MAPS = _class.staticFieldId( + r"CATEGORY_APP_MAPS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_MAPS /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_MAPS => - _get_CATEGORY_APP_MAPS().object(const jni.JStringType()); + _id_CATEGORY_APP_MAPS.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_MARKET = - jniLookup>( - "get_Intent__CATEGORY_APP_MARKET") - .asFunction(); + static final _id_CATEGORY_APP_MARKET = _class.staticFieldId( + r"CATEGORY_APP_MARKET", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_MARKET /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_MARKET => - _get_CATEGORY_APP_MARKET().object(const jni.JStringType()); + _id_CATEGORY_APP_MARKET.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_MESSAGING = - jniLookup>( - "get_Intent__CATEGORY_APP_MESSAGING") - .asFunction(); + static final _id_CATEGORY_APP_MESSAGING = _class.staticFieldId( + r"CATEGORY_APP_MESSAGING", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_MESSAGING /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_MESSAGING => - _get_CATEGORY_APP_MESSAGING().object(const jni.JStringType()); + _id_CATEGORY_APP_MESSAGING.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_MUSIC = - jniLookup>( - "get_Intent__CATEGORY_APP_MUSIC") - .asFunction(); + static final _id_CATEGORY_APP_MUSIC = _class.staticFieldId( + r"CATEGORY_APP_MUSIC", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_MUSIC /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_MUSIC => - _get_CATEGORY_APP_MUSIC().object(const jni.JStringType()); + _id_CATEGORY_APP_MUSIC.get(_class, const jni.JStringType()); - static final _get_CATEGORY_APP_WEATHER = - jniLookup>( - "get_Intent__CATEGORY_APP_WEATHER") - .asFunction(); + static final _id_CATEGORY_APP_WEATHER = _class.staticFieldId( + r"CATEGORY_APP_WEATHER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_APP_WEATHER /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_APP_WEATHER => - _get_CATEGORY_APP_WEATHER().object(const jni.JStringType()); + _id_CATEGORY_APP_WEATHER.get(_class, const jni.JStringType()); - static final _get_CATEGORY_BROWSABLE = - jniLookup>( - "get_Intent__CATEGORY_BROWSABLE") - .asFunction(); + static final _id_CATEGORY_BROWSABLE = _class.staticFieldId( + r"CATEGORY_BROWSABLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_BROWSABLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_BROWSABLE => - _get_CATEGORY_BROWSABLE().object(const jni.JStringType()); + _id_CATEGORY_BROWSABLE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_CAR_DOCK = - jniLookup>( - "get_Intent__CATEGORY_CAR_DOCK") - .asFunction(); + static final _id_CATEGORY_CAR_DOCK = _class.staticFieldId( + r"CATEGORY_CAR_DOCK", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_CAR_DOCK /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_CAR_DOCK => - _get_CATEGORY_CAR_DOCK().object(const jni.JStringType()); + _id_CATEGORY_CAR_DOCK.get(_class, const jni.JStringType()); - static final _get_CATEGORY_CAR_MODE = - jniLookup>( - "get_Intent__CATEGORY_CAR_MODE") - .asFunction(); + static final _id_CATEGORY_CAR_MODE = _class.staticFieldId( + r"CATEGORY_CAR_MODE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_CAR_MODE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_CAR_MODE => - _get_CATEGORY_CAR_MODE().object(const jni.JStringType()); + _id_CATEGORY_CAR_MODE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_DEFAULT = - jniLookup>( - "get_Intent__CATEGORY_DEFAULT") - .asFunction(); + static final _id_CATEGORY_DEFAULT = _class.staticFieldId( + r"CATEGORY_DEFAULT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_DEFAULT /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_DEFAULT => - _get_CATEGORY_DEFAULT().object(const jni.JStringType()); + _id_CATEGORY_DEFAULT.get(_class, const jni.JStringType()); - static final _get_CATEGORY_DESK_DOCK = - jniLookup>( - "get_Intent__CATEGORY_DESK_DOCK") - .asFunction(); + static final _id_CATEGORY_DESK_DOCK = _class.staticFieldId( + r"CATEGORY_DESK_DOCK", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_DESK_DOCK /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_DESK_DOCK => - _get_CATEGORY_DESK_DOCK().object(const jni.JStringType()); + _id_CATEGORY_DESK_DOCK.get(_class, const jni.JStringType()); - static final _get_CATEGORY_DEVELOPMENT_PREFERENCE = - jniLookup>( - "get_Intent__CATEGORY_DEVELOPMENT_PREFERENCE") - .asFunction(); + static final _id_CATEGORY_DEVELOPMENT_PREFERENCE = _class.staticFieldId( + r"CATEGORY_DEVELOPMENT_PREFERENCE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_DEVELOPMENT_PREFERENCE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_DEVELOPMENT_PREFERENCE => - _get_CATEGORY_DEVELOPMENT_PREFERENCE().object(const jni.JStringType()); + _id_CATEGORY_DEVELOPMENT_PREFERENCE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_EMBED = - jniLookup>( - "get_Intent__CATEGORY_EMBED") - .asFunction(); + static final _id_CATEGORY_EMBED = _class.staticFieldId( + r"CATEGORY_EMBED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_EMBED /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_EMBED => - _get_CATEGORY_EMBED().object(const jni.JStringType()); + _id_CATEGORY_EMBED.get(_class, const jni.JStringType()); - static final _get_CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST = - jniLookup>( - "get_Intent__CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST") - .asFunction(); + static final _id_CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST = + _class.staticFieldId( + r"CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST => - _get_CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST() - .object(const jni.JStringType()); + _id_CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST.get( + _class, const jni.JStringType()); - static final _get_CATEGORY_HE_DESK_DOCK = - jniLookup>( - "get_Intent__CATEGORY_HE_DESK_DOCK") - .asFunction(); + static final _id_CATEGORY_HE_DESK_DOCK = _class.staticFieldId( + r"CATEGORY_HE_DESK_DOCK", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_HE_DESK_DOCK /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_HE_DESK_DOCK => - _get_CATEGORY_HE_DESK_DOCK().object(const jni.JStringType()); + _id_CATEGORY_HE_DESK_DOCK.get(_class, const jni.JStringType()); - static final _get_CATEGORY_HOME = - jniLookup>( - "get_Intent__CATEGORY_HOME") - .asFunction(); + static final _id_CATEGORY_HOME = _class.staticFieldId( + r"CATEGORY_HOME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_HOME /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_HOME => - _get_CATEGORY_HOME().object(const jni.JStringType()); + _id_CATEGORY_HOME.get(_class, const jni.JStringType()); - static final _get_CATEGORY_INFO = - jniLookup>( - "get_Intent__CATEGORY_INFO") - .asFunction(); + static final _id_CATEGORY_INFO = _class.staticFieldId( + r"CATEGORY_INFO", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_INFO /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_INFO => - _get_CATEGORY_INFO().object(const jni.JStringType()); + _id_CATEGORY_INFO.get(_class, const jni.JStringType()); - static final _get_CATEGORY_LAUNCHER = - jniLookup>( - "get_Intent__CATEGORY_LAUNCHER") - .asFunction(); + static final _id_CATEGORY_LAUNCHER = _class.staticFieldId( + r"CATEGORY_LAUNCHER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_LAUNCHER /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_LAUNCHER => - _get_CATEGORY_LAUNCHER().object(const jni.JStringType()); + _id_CATEGORY_LAUNCHER.get(_class, const jni.JStringType()); - static final _get_CATEGORY_LEANBACK_LAUNCHER = - jniLookup>( - "get_Intent__CATEGORY_LEANBACK_LAUNCHER") - .asFunction(); + static final _id_CATEGORY_LEANBACK_LAUNCHER = _class.staticFieldId( + r"CATEGORY_LEANBACK_LAUNCHER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_LEANBACK_LAUNCHER /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_LEANBACK_LAUNCHER => - _get_CATEGORY_LEANBACK_LAUNCHER().object(const jni.JStringType()); + _id_CATEGORY_LEANBACK_LAUNCHER.get(_class, const jni.JStringType()); - static final _get_CATEGORY_LE_DESK_DOCK = - jniLookup>( - "get_Intent__CATEGORY_LE_DESK_DOCK") - .asFunction(); + static final _id_CATEGORY_LE_DESK_DOCK = _class.staticFieldId( + r"CATEGORY_LE_DESK_DOCK", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_LE_DESK_DOCK /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_LE_DESK_DOCK => - _get_CATEGORY_LE_DESK_DOCK().object(const jni.JStringType()); + _id_CATEGORY_LE_DESK_DOCK.get(_class, const jni.JStringType()); - static final _get_CATEGORY_MONKEY = - jniLookup>( - "get_Intent__CATEGORY_MONKEY") - .asFunction(); + static final _id_CATEGORY_MONKEY = _class.staticFieldId( + r"CATEGORY_MONKEY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_MONKEY /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_MONKEY => - _get_CATEGORY_MONKEY().object(const jni.JStringType()); + _id_CATEGORY_MONKEY.get(_class, const jni.JStringType()); - static final _get_CATEGORY_OPENABLE = - jniLookup>( - "get_Intent__CATEGORY_OPENABLE") - .asFunction(); + static final _id_CATEGORY_OPENABLE = _class.staticFieldId( + r"CATEGORY_OPENABLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_OPENABLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_OPENABLE => - _get_CATEGORY_OPENABLE().object(const jni.JStringType()); + _id_CATEGORY_OPENABLE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_PREFERENCE = - jniLookup>( - "get_Intent__CATEGORY_PREFERENCE") - .asFunction(); + static final _id_CATEGORY_PREFERENCE = _class.staticFieldId( + r"CATEGORY_PREFERENCE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_PREFERENCE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_PREFERENCE => - _get_CATEGORY_PREFERENCE().object(const jni.JStringType()); + _id_CATEGORY_PREFERENCE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_SAMPLE_CODE = - jniLookup>( - "get_Intent__CATEGORY_SAMPLE_CODE") - .asFunction(); + static final _id_CATEGORY_SAMPLE_CODE = _class.staticFieldId( + r"CATEGORY_SAMPLE_CODE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_SAMPLE_CODE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_SAMPLE_CODE => - _get_CATEGORY_SAMPLE_CODE().object(const jni.JStringType()); + _id_CATEGORY_SAMPLE_CODE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_SECONDARY_HOME = - jniLookup>( - "get_Intent__CATEGORY_SECONDARY_HOME") - .asFunction(); + static final _id_CATEGORY_SECONDARY_HOME = _class.staticFieldId( + r"CATEGORY_SECONDARY_HOME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_SECONDARY_HOME /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_SECONDARY_HOME => - _get_CATEGORY_SECONDARY_HOME().object(const jni.JStringType()); + _id_CATEGORY_SECONDARY_HOME.get(_class, const jni.JStringType()); - static final _get_CATEGORY_SELECTED_ALTERNATIVE = - jniLookup>( - "get_Intent__CATEGORY_SELECTED_ALTERNATIVE") - .asFunction(); + static final _id_CATEGORY_SELECTED_ALTERNATIVE = _class.staticFieldId( + r"CATEGORY_SELECTED_ALTERNATIVE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_SELECTED_ALTERNATIVE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_SELECTED_ALTERNATIVE => - _get_CATEGORY_SELECTED_ALTERNATIVE().object(const jni.JStringType()); + _id_CATEGORY_SELECTED_ALTERNATIVE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_TAB = - jniLookup>( - "get_Intent__CATEGORY_TAB") - .asFunction(); + static final _id_CATEGORY_TAB = _class.staticFieldId( + r"CATEGORY_TAB", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_TAB /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_TAB => - _get_CATEGORY_TAB().object(const jni.JStringType()); + _id_CATEGORY_TAB.get(_class, const jni.JStringType()); - static final _get_CATEGORY_TEST = - jniLookup>( - "get_Intent__CATEGORY_TEST") - .asFunction(); + static final _id_CATEGORY_TEST = _class.staticFieldId( + r"CATEGORY_TEST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_TEST /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_TEST => - _get_CATEGORY_TEST().object(const jni.JStringType()); + _id_CATEGORY_TEST.get(_class, const jni.JStringType()); - static final _get_CATEGORY_TYPED_OPENABLE = - jniLookup>( - "get_Intent__CATEGORY_TYPED_OPENABLE") - .asFunction(); + static final _id_CATEGORY_TYPED_OPENABLE = _class.staticFieldId( + r"CATEGORY_TYPED_OPENABLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_TYPED_OPENABLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_TYPED_OPENABLE => - _get_CATEGORY_TYPED_OPENABLE().object(const jni.JStringType()); + _id_CATEGORY_TYPED_OPENABLE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_UNIT_TEST = - jniLookup>( - "get_Intent__CATEGORY_UNIT_TEST") - .asFunction(); + static final _id_CATEGORY_UNIT_TEST = _class.staticFieldId( + r"CATEGORY_UNIT_TEST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_UNIT_TEST /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_UNIT_TEST => - _get_CATEGORY_UNIT_TEST().object(const jni.JStringType()); + _id_CATEGORY_UNIT_TEST.get(_class, const jni.JStringType()); - static final _get_CATEGORY_VOICE = - jniLookup>( - "get_Intent__CATEGORY_VOICE") - .asFunction(); + static final _id_CATEGORY_VOICE = _class.staticFieldId( + r"CATEGORY_VOICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_VOICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_VOICE => - _get_CATEGORY_VOICE().object(const jni.JStringType()); + _id_CATEGORY_VOICE.get(_class, const jni.JStringType()); - static final _get_CATEGORY_VR_HOME = - jniLookup>( - "get_Intent__CATEGORY_VR_HOME") - .asFunction(); + static final _id_CATEGORY_VR_HOME = _class.staticFieldId( + r"CATEGORY_VR_HOME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String CATEGORY_VR_HOME /// The returned object must be released after use, by calling the [release] method. static jni.JString get CATEGORY_VR_HOME => - _get_CATEGORY_VR_HOME().object(const jni.JStringType()); + _id_CATEGORY_VR_HOME.get(_class, const jni.JStringType()); - static final _get_CREATOR = - jniLookup>( - "get_Intent__CREATOR") - .asFunction(); + static final _id_CREATOR = _class.staticFieldId( + r"CREATOR", + r"Landroid/os/Parcelable$Creator;", + ); /// from: static public final android.os.Parcelable$Creator CREATOR /// The returned object must be released after use, by calling the [release] method. static jni.JObject get CREATOR => - _get_CREATOR().object(const jni.JObjectType()); + _id_CREATOR.get(_class, const jni.JObjectType()); - static final _get_EXTRA_ALARM_COUNT = - jniLookup>( - "get_Intent__EXTRA_ALARM_COUNT") - .asFunction(); + static final _id_EXTRA_ALARM_COUNT = _class.staticFieldId( + r"EXTRA_ALARM_COUNT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ALARM_COUNT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ALARM_COUNT => - _get_EXTRA_ALARM_COUNT().object(const jni.JStringType()); + _id_EXTRA_ALARM_COUNT.get(_class, const jni.JStringType()); - static final _get_EXTRA_ALLOW_MULTIPLE = - jniLookup>( - "get_Intent__EXTRA_ALLOW_MULTIPLE") - .asFunction(); + static final _id_EXTRA_ALLOW_MULTIPLE = _class.staticFieldId( + r"EXTRA_ALLOW_MULTIPLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ALLOW_MULTIPLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ALLOW_MULTIPLE => - _get_EXTRA_ALLOW_MULTIPLE().object(const jni.JStringType()); + _id_EXTRA_ALLOW_MULTIPLE.get(_class, const jni.JStringType()); - static final _get_EXTRA_ALLOW_REPLACE = - jniLookup>( - "get_Intent__EXTRA_ALLOW_REPLACE") - .asFunction(); + static final _id_EXTRA_ALLOW_REPLACE = _class.staticFieldId( + r"EXTRA_ALLOW_REPLACE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ALLOW_REPLACE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ALLOW_REPLACE => - _get_EXTRA_ALLOW_REPLACE().object(const jni.JStringType()); + _id_EXTRA_ALLOW_REPLACE.get(_class, const jni.JStringType()); - static final _get_EXTRA_ALTERNATE_INTENTS = - jniLookup>( - "get_Intent__EXTRA_ALTERNATE_INTENTS") - .asFunction(); + static final _id_EXTRA_ALTERNATE_INTENTS = _class.staticFieldId( + r"EXTRA_ALTERNATE_INTENTS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ALTERNATE_INTENTS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ALTERNATE_INTENTS => - _get_EXTRA_ALTERNATE_INTENTS().object(const jni.JStringType()); + _id_EXTRA_ALTERNATE_INTENTS.get(_class, const jni.JStringType()); - static final _get_EXTRA_ASSIST_CONTEXT = - jniLookup>( - "get_Intent__EXTRA_ASSIST_CONTEXT") - .asFunction(); + static final _id_EXTRA_ASSIST_CONTEXT = _class.staticFieldId( + r"EXTRA_ASSIST_CONTEXT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ASSIST_CONTEXT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ASSIST_CONTEXT => - _get_EXTRA_ASSIST_CONTEXT().object(const jni.JStringType()); + _id_EXTRA_ASSIST_CONTEXT.get(_class, const jni.JStringType()); - static final _get_EXTRA_ASSIST_INPUT_DEVICE_ID = - jniLookup>( - "get_Intent__EXTRA_ASSIST_INPUT_DEVICE_ID") - .asFunction(); + static final _id_EXTRA_ASSIST_INPUT_DEVICE_ID = _class.staticFieldId( + r"EXTRA_ASSIST_INPUT_DEVICE_ID", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ASSIST_INPUT_DEVICE_ID /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ASSIST_INPUT_DEVICE_ID => - _get_EXTRA_ASSIST_INPUT_DEVICE_ID().object(const jni.JStringType()); + _id_EXTRA_ASSIST_INPUT_DEVICE_ID.get(_class, const jni.JStringType()); - static final _get_EXTRA_ASSIST_INPUT_HINT_KEYBOARD = - jniLookup>( - "get_Intent__EXTRA_ASSIST_INPUT_HINT_KEYBOARD") - .asFunction(); + static final _id_EXTRA_ASSIST_INPUT_HINT_KEYBOARD = _class.staticFieldId( + r"EXTRA_ASSIST_INPUT_HINT_KEYBOARD", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ASSIST_INPUT_HINT_KEYBOARD /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ASSIST_INPUT_HINT_KEYBOARD => - _get_EXTRA_ASSIST_INPUT_HINT_KEYBOARD().object(const jni.JStringType()); + _id_EXTRA_ASSIST_INPUT_HINT_KEYBOARD.get(_class, const jni.JStringType()); - static final _get_EXTRA_ASSIST_PACKAGE = - jniLookup>( - "get_Intent__EXTRA_ASSIST_PACKAGE") - .asFunction(); + static final _id_EXTRA_ASSIST_PACKAGE = _class.staticFieldId( + r"EXTRA_ASSIST_PACKAGE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ASSIST_PACKAGE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ASSIST_PACKAGE => - _get_EXTRA_ASSIST_PACKAGE().object(const jni.JStringType()); + _id_EXTRA_ASSIST_PACKAGE.get(_class, const jni.JStringType()); - static final _get_EXTRA_ASSIST_UID = - jniLookup>( - "get_Intent__EXTRA_ASSIST_UID") - .asFunction(); + static final _id_EXTRA_ASSIST_UID = _class.staticFieldId( + r"EXTRA_ASSIST_UID", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ASSIST_UID /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ASSIST_UID => - _get_EXTRA_ASSIST_UID().object(const jni.JStringType()); + _id_EXTRA_ASSIST_UID.get(_class, const jni.JStringType()); - static final _get_EXTRA_ATTRIBUTION_TAGS = - jniLookup>( - "get_Intent__EXTRA_ATTRIBUTION_TAGS") - .asFunction(); + static final _id_EXTRA_ATTRIBUTION_TAGS = _class.staticFieldId( + r"EXTRA_ATTRIBUTION_TAGS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ATTRIBUTION_TAGS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ATTRIBUTION_TAGS => - _get_EXTRA_ATTRIBUTION_TAGS().object(const jni.JStringType()); + _id_EXTRA_ATTRIBUTION_TAGS.get(_class, const jni.JStringType()); - static final _get_EXTRA_AUTO_LAUNCH_SINGLE_CHOICE = - jniLookup>( - "get_Intent__EXTRA_AUTO_LAUNCH_SINGLE_CHOICE") - .asFunction(); + static final _id_EXTRA_AUTO_LAUNCH_SINGLE_CHOICE = _class.staticFieldId( + r"EXTRA_AUTO_LAUNCH_SINGLE_CHOICE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_AUTO_LAUNCH_SINGLE_CHOICE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_AUTO_LAUNCH_SINGLE_CHOICE => - _get_EXTRA_AUTO_LAUNCH_SINGLE_CHOICE().object(const jni.JStringType()); + _id_EXTRA_AUTO_LAUNCH_SINGLE_CHOICE.get(_class, const jni.JStringType()); - static final _get_EXTRA_BCC = - jniLookup>( - "get_Intent__EXTRA_BCC") - .asFunction(); + static final _id_EXTRA_BCC = _class.staticFieldId( + r"EXTRA_BCC", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_BCC /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_BCC => - _get_EXTRA_BCC().object(const jni.JStringType()); + _id_EXTRA_BCC.get(_class, const jni.JStringType()); - static final _get_EXTRA_BUG_REPORT = - jniLookup>( - "get_Intent__EXTRA_BUG_REPORT") - .asFunction(); + static final _id_EXTRA_BUG_REPORT = _class.staticFieldId( + r"EXTRA_BUG_REPORT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_BUG_REPORT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_BUG_REPORT => - _get_EXTRA_BUG_REPORT().object(const jni.JStringType()); + _id_EXTRA_BUG_REPORT.get(_class, const jni.JStringType()); - static final _get_EXTRA_CC = - jniLookup>( - "get_Intent__EXTRA_CC") - .asFunction(); + static final _id_EXTRA_CC = _class.staticFieldId( + r"EXTRA_CC", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CC /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CC => - _get_EXTRA_CC().object(const jni.JStringType()); + _id_EXTRA_CC.get(_class, const jni.JStringType()); - static final _get_EXTRA_CHANGED_COMPONENT_NAME = - jniLookup>( - "get_Intent__EXTRA_CHANGED_COMPONENT_NAME") - .asFunction(); + static final _id_EXTRA_CHANGED_COMPONENT_NAME = _class.staticFieldId( + r"EXTRA_CHANGED_COMPONENT_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CHANGED_COMPONENT_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CHANGED_COMPONENT_NAME => - _get_EXTRA_CHANGED_COMPONENT_NAME().object(const jni.JStringType()); + _id_EXTRA_CHANGED_COMPONENT_NAME.get(_class, const jni.JStringType()); - static final _get_EXTRA_CHANGED_COMPONENT_NAME_LIST = - jniLookup>( - "get_Intent__EXTRA_CHANGED_COMPONENT_NAME_LIST") - .asFunction(); + static final _id_EXTRA_CHANGED_COMPONENT_NAME_LIST = _class.staticFieldId( + r"EXTRA_CHANGED_COMPONENT_NAME_LIST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CHANGED_COMPONENT_NAME_LIST /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CHANGED_COMPONENT_NAME_LIST => - _get_EXTRA_CHANGED_COMPONENT_NAME_LIST().object(const jni.JStringType()); + _id_EXTRA_CHANGED_COMPONENT_NAME_LIST.get( + _class, const jni.JStringType()); - static final _get_EXTRA_CHANGED_PACKAGE_LIST = - jniLookup>( - "get_Intent__EXTRA_CHANGED_PACKAGE_LIST") - .asFunction(); + static final _id_EXTRA_CHANGED_PACKAGE_LIST = _class.staticFieldId( + r"EXTRA_CHANGED_PACKAGE_LIST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CHANGED_PACKAGE_LIST /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CHANGED_PACKAGE_LIST => - _get_EXTRA_CHANGED_PACKAGE_LIST().object(const jni.JStringType()); + _id_EXTRA_CHANGED_PACKAGE_LIST.get(_class, const jni.JStringType()); - static final _get_EXTRA_CHANGED_UID_LIST = - jniLookup>( - "get_Intent__EXTRA_CHANGED_UID_LIST") - .asFunction(); + static final _id_EXTRA_CHANGED_UID_LIST = _class.staticFieldId( + r"EXTRA_CHANGED_UID_LIST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CHANGED_UID_LIST /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CHANGED_UID_LIST => - _get_EXTRA_CHANGED_UID_LIST().object(const jni.JStringType()); + _id_EXTRA_CHANGED_UID_LIST.get(_class, const jni.JStringType()); - static final _get_EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER = - jniLookup>( - "get_Intent__EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER") - .asFunction(); + static final _id_EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER = + _class.staticFieldId( + r"EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER => - _get_EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER() - .object(const jni.JStringType()); + _id_EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER.get( + _class, const jni.JStringType()); - static final _get_EXTRA_CHOOSER_TARGETS = - jniLookup>( - "get_Intent__EXTRA_CHOOSER_TARGETS") - .asFunction(); + static final _id_EXTRA_CHOOSER_TARGETS = _class.staticFieldId( + r"EXTRA_CHOOSER_TARGETS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CHOOSER_TARGETS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CHOOSER_TARGETS => - _get_EXTRA_CHOOSER_TARGETS().object(const jni.JStringType()); + _id_EXTRA_CHOOSER_TARGETS.get(_class, const jni.JStringType()); - static final _get_EXTRA_CHOSEN_COMPONENT = - jniLookup>( - "get_Intent__EXTRA_CHOSEN_COMPONENT") - .asFunction(); + static final _id_EXTRA_CHOSEN_COMPONENT = _class.staticFieldId( + r"EXTRA_CHOSEN_COMPONENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CHOSEN_COMPONENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CHOSEN_COMPONENT => - _get_EXTRA_CHOSEN_COMPONENT().object(const jni.JStringType()); + _id_EXTRA_CHOSEN_COMPONENT.get(_class, const jni.JStringType()); - static final _get_EXTRA_CHOSEN_COMPONENT_INTENT_SENDER = - jniLookup>( - "get_Intent__EXTRA_CHOSEN_COMPONENT_INTENT_SENDER") - .asFunction(); + static final _id_EXTRA_CHOSEN_COMPONENT_INTENT_SENDER = _class.staticFieldId( + r"EXTRA_CHOSEN_COMPONENT_INTENT_SENDER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CHOSEN_COMPONENT_INTENT_SENDER /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CHOSEN_COMPONENT_INTENT_SENDER => - _get_EXTRA_CHOSEN_COMPONENT_INTENT_SENDER() - .object(const jni.JStringType()); + _id_EXTRA_CHOSEN_COMPONENT_INTENT_SENDER.get( + _class, const jni.JStringType()); - static final _get_EXTRA_COMPONENT_NAME = - jniLookup>( - "get_Intent__EXTRA_COMPONENT_NAME") - .asFunction(); + static final _id_EXTRA_COMPONENT_NAME = _class.staticFieldId( + r"EXTRA_COMPONENT_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_COMPONENT_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_COMPONENT_NAME => - _get_EXTRA_COMPONENT_NAME().object(const jni.JStringType()); + _id_EXTRA_COMPONENT_NAME.get(_class, const jni.JStringType()); - static final _get_EXTRA_CONTENT_ANNOTATIONS = - jniLookup>( - "get_Intent__EXTRA_CONTENT_ANNOTATIONS") - .asFunction(); + static final _id_EXTRA_CONTENT_ANNOTATIONS = _class.staticFieldId( + r"EXTRA_CONTENT_ANNOTATIONS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CONTENT_ANNOTATIONS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CONTENT_ANNOTATIONS => - _get_EXTRA_CONTENT_ANNOTATIONS().object(const jni.JStringType()); + _id_EXTRA_CONTENT_ANNOTATIONS.get(_class, const jni.JStringType()); - static final _get_EXTRA_CONTENT_QUERY = - jniLookup>( - "get_Intent__EXTRA_CONTENT_QUERY") - .asFunction(); + static final _id_EXTRA_CONTENT_QUERY = _class.staticFieldId( + r"EXTRA_CONTENT_QUERY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_CONTENT_QUERY /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_CONTENT_QUERY => - _get_EXTRA_CONTENT_QUERY().object(const jni.JStringType()); + _id_EXTRA_CONTENT_QUERY.get(_class, const jni.JStringType()); - static final _get_EXTRA_DATA_REMOVED = - jniLookup>( - "get_Intent__EXTRA_DATA_REMOVED") - .asFunction(); + static final _id_EXTRA_DATA_REMOVED = _class.staticFieldId( + r"EXTRA_DATA_REMOVED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_DATA_REMOVED /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_DATA_REMOVED => - _get_EXTRA_DATA_REMOVED().object(const jni.JStringType()); + _id_EXTRA_DATA_REMOVED.get(_class, const jni.JStringType()); - static final _get_EXTRA_DOCK_STATE = - jniLookup>( - "get_Intent__EXTRA_DOCK_STATE") - .asFunction(); + static final _id_EXTRA_DOCK_STATE = _class.staticFieldId( + r"EXTRA_DOCK_STATE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_DOCK_STATE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_DOCK_STATE => - _get_EXTRA_DOCK_STATE().object(const jni.JStringType()); + _id_EXTRA_DOCK_STATE.get(_class, const jni.JStringType()); /// from: static public final int EXTRA_DOCK_STATE_CAR static const EXTRA_DOCK_STATE_CAR = 2; @@ -7600,545 +10025,545 @@ class Intent extends jni.JObject { /// from: static public final int EXTRA_DOCK_STATE_UNDOCKED static const EXTRA_DOCK_STATE_UNDOCKED = 0; - static final _get_EXTRA_DONT_KILL_APP = - jniLookup>( - "get_Intent__EXTRA_DONT_KILL_APP") - .asFunction(); + static final _id_EXTRA_DONT_KILL_APP = _class.staticFieldId( + r"EXTRA_DONT_KILL_APP", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_DONT_KILL_APP /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_DONT_KILL_APP => - _get_EXTRA_DONT_KILL_APP().object(const jni.JStringType()); + _id_EXTRA_DONT_KILL_APP.get(_class, const jni.JStringType()); - static final _get_EXTRA_DURATION_MILLIS = - jniLookup>( - "get_Intent__EXTRA_DURATION_MILLIS") - .asFunction(); + static final _id_EXTRA_DURATION_MILLIS = _class.staticFieldId( + r"EXTRA_DURATION_MILLIS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_DURATION_MILLIS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_DURATION_MILLIS => - _get_EXTRA_DURATION_MILLIS().object(const jni.JStringType()); + _id_EXTRA_DURATION_MILLIS.get(_class, const jni.JStringType()); - static final _get_EXTRA_EMAIL = - jniLookup>( - "get_Intent__EXTRA_EMAIL") - .asFunction(); + static final _id_EXTRA_EMAIL = _class.staticFieldId( + r"EXTRA_EMAIL", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_EMAIL /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_EMAIL => - _get_EXTRA_EMAIL().object(const jni.JStringType()); + _id_EXTRA_EMAIL.get(_class, const jni.JStringType()); - static final _get_EXTRA_END_TIME = - jniLookup>( - "get_Intent__EXTRA_END_TIME") - .asFunction(); + static final _id_EXTRA_END_TIME = _class.staticFieldId( + r"EXTRA_END_TIME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_END_TIME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_END_TIME => - _get_EXTRA_END_TIME().object(const jni.JStringType()); + _id_EXTRA_END_TIME.get(_class, const jni.JStringType()); - static final _get_EXTRA_EXCLUDE_COMPONENTS = - jniLookup>( - "get_Intent__EXTRA_EXCLUDE_COMPONENTS") - .asFunction(); + static final _id_EXTRA_EXCLUDE_COMPONENTS = _class.staticFieldId( + r"EXTRA_EXCLUDE_COMPONENTS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_EXCLUDE_COMPONENTS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_EXCLUDE_COMPONENTS => - _get_EXTRA_EXCLUDE_COMPONENTS().object(const jni.JStringType()); + _id_EXTRA_EXCLUDE_COMPONENTS.get(_class, const jni.JStringType()); - static final _get_EXTRA_FROM_STORAGE = - jniLookup>( - "get_Intent__EXTRA_FROM_STORAGE") - .asFunction(); + static final _id_EXTRA_FROM_STORAGE = _class.staticFieldId( + r"EXTRA_FROM_STORAGE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_FROM_STORAGE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_FROM_STORAGE => - _get_EXTRA_FROM_STORAGE().object(const jni.JStringType()); + _id_EXTRA_FROM_STORAGE.get(_class, const jni.JStringType()); - static final _get_EXTRA_HTML_TEXT = - jniLookup>( - "get_Intent__EXTRA_HTML_TEXT") - .asFunction(); + static final _id_EXTRA_HTML_TEXT = _class.staticFieldId( + r"EXTRA_HTML_TEXT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_HTML_TEXT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_HTML_TEXT => - _get_EXTRA_HTML_TEXT().object(const jni.JStringType()); + _id_EXTRA_HTML_TEXT.get(_class, const jni.JStringType()); - static final _get_EXTRA_INDEX = - jniLookup>( - "get_Intent__EXTRA_INDEX") - .asFunction(); + static final _id_EXTRA_INDEX = _class.staticFieldId( + r"EXTRA_INDEX", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_INDEX /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_INDEX => - _get_EXTRA_INDEX().object(const jni.JStringType()); + _id_EXTRA_INDEX.get(_class, const jni.JStringType()); - static final _get_EXTRA_INITIAL_INTENTS = - jniLookup>( - "get_Intent__EXTRA_INITIAL_INTENTS") - .asFunction(); + static final _id_EXTRA_INITIAL_INTENTS = _class.staticFieldId( + r"EXTRA_INITIAL_INTENTS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_INITIAL_INTENTS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_INITIAL_INTENTS => - _get_EXTRA_INITIAL_INTENTS().object(const jni.JStringType()); + _id_EXTRA_INITIAL_INTENTS.get(_class, const jni.JStringType()); - static final _get_EXTRA_INSTALLER_PACKAGE_NAME = - jniLookup>( - "get_Intent__EXTRA_INSTALLER_PACKAGE_NAME") - .asFunction(); + static final _id_EXTRA_INSTALLER_PACKAGE_NAME = _class.staticFieldId( + r"EXTRA_INSTALLER_PACKAGE_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_INSTALLER_PACKAGE_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_INSTALLER_PACKAGE_NAME => - _get_EXTRA_INSTALLER_PACKAGE_NAME().object(const jni.JStringType()); + _id_EXTRA_INSTALLER_PACKAGE_NAME.get(_class, const jni.JStringType()); - static final _get_EXTRA_INTENT = - jniLookup>( - "get_Intent__EXTRA_INTENT") - .asFunction(); + static final _id_EXTRA_INTENT = _class.staticFieldId( + r"EXTRA_INTENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_INTENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_INTENT => - _get_EXTRA_INTENT().object(const jni.JStringType()); + _id_EXTRA_INTENT.get(_class, const jni.JStringType()); - static final _get_EXTRA_KEY_EVENT = - jniLookup>( - "get_Intent__EXTRA_KEY_EVENT") - .asFunction(); + static final _id_EXTRA_KEY_EVENT = _class.staticFieldId( + r"EXTRA_KEY_EVENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_KEY_EVENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_KEY_EVENT => - _get_EXTRA_KEY_EVENT().object(const jni.JStringType()); + _id_EXTRA_KEY_EVENT.get(_class, const jni.JStringType()); - static final _get_EXTRA_LOCALE_LIST = - jniLookup>( - "get_Intent__EXTRA_LOCALE_LIST") - .asFunction(); + static final _id_EXTRA_LOCALE_LIST = _class.staticFieldId( + r"EXTRA_LOCALE_LIST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_LOCALE_LIST /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_LOCALE_LIST => - _get_EXTRA_LOCALE_LIST().object(const jni.JStringType()); + _id_EXTRA_LOCALE_LIST.get(_class, const jni.JStringType()); - static final _get_EXTRA_LOCAL_ONLY = - jniLookup>( - "get_Intent__EXTRA_LOCAL_ONLY") - .asFunction(); + static final _id_EXTRA_LOCAL_ONLY = _class.staticFieldId( + r"EXTRA_LOCAL_ONLY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_LOCAL_ONLY /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_LOCAL_ONLY => - _get_EXTRA_LOCAL_ONLY().object(const jni.JStringType()); + _id_EXTRA_LOCAL_ONLY.get(_class, const jni.JStringType()); - static final _get_EXTRA_LOCUS_ID = - jniLookup>( - "get_Intent__EXTRA_LOCUS_ID") - .asFunction(); + static final _id_EXTRA_LOCUS_ID = _class.staticFieldId( + r"EXTRA_LOCUS_ID", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_LOCUS_ID /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_LOCUS_ID => - _get_EXTRA_LOCUS_ID().object(const jni.JStringType()); + _id_EXTRA_LOCUS_ID.get(_class, const jni.JStringType()); - static final _get_EXTRA_MIME_TYPES = - jniLookup>( - "get_Intent__EXTRA_MIME_TYPES") - .asFunction(); + static final _id_EXTRA_MIME_TYPES = _class.staticFieldId( + r"EXTRA_MIME_TYPES", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_MIME_TYPES /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_MIME_TYPES => - _get_EXTRA_MIME_TYPES().object(const jni.JStringType()); + _id_EXTRA_MIME_TYPES.get(_class, const jni.JStringType()); - static final _get_EXTRA_NOT_UNKNOWN_SOURCE = - jniLookup>( - "get_Intent__EXTRA_NOT_UNKNOWN_SOURCE") - .asFunction(); + static final _id_EXTRA_NOT_UNKNOWN_SOURCE = _class.staticFieldId( + r"EXTRA_NOT_UNKNOWN_SOURCE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_NOT_UNKNOWN_SOURCE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_NOT_UNKNOWN_SOURCE => - _get_EXTRA_NOT_UNKNOWN_SOURCE().object(const jni.JStringType()); + _id_EXTRA_NOT_UNKNOWN_SOURCE.get(_class, const jni.JStringType()); - static final _get_EXTRA_ORIGINATING_URI = - jniLookup>( - "get_Intent__EXTRA_ORIGINATING_URI") - .asFunction(); + static final _id_EXTRA_ORIGINATING_URI = _class.staticFieldId( + r"EXTRA_ORIGINATING_URI", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_ORIGINATING_URI /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_ORIGINATING_URI => - _get_EXTRA_ORIGINATING_URI().object(const jni.JStringType()); + _id_EXTRA_ORIGINATING_URI.get(_class, const jni.JStringType()); - static final _get_EXTRA_PACKAGE_NAME = - jniLookup>( - "get_Intent__EXTRA_PACKAGE_NAME") - .asFunction(); + static final _id_EXTRA_PACKAGE_NAME = _class.staticFieldId( + r"EXTRA_PACKAGE_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_PACKAGE_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_PACKAGE_NAME => - _get_EXTRA_PACKAGE_NAME().object(const jni.JStringType()); + _id_EXTRA_PACKAGE_NAME.get(_class, const jni.JStringType()); - static final _get_EXTRA_PERMISSION_GROUP_NAME = - jniLookup>( - "get_Intent__EXTRA_PERMISSION_GROUP_NAME") - .asFunction(); + static final _id_EXTRA_PERMISSION_GROUP_NAME = _class.staticFieldId( + r"EXTRA_PERMISSION_GROUP_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_PERMISSION_GROUP_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_PERMISSION_GROUP_NAME => - _get_EXTRA_PERMISSION_GROUP_NAME().object(const jni.JStringType()); + _id_EXTRA_PERMISSION_GROUP_NAME.get(_class, const jni.JStringType()); - static final _get_EXTRA_PHONE_NUMBER = - jniLookup>( - "get_Intent__EXTRA_PHONE_NUMBER") - .asFunction(); + static final _id_EXTRA_PHONE_NUMBER = _class.staticFieldId( + r"EXTRA_PHONE_NUMBER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_PHONE_NUMBER /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_PHONE_NUMBER => - _get_EXTRA_PHONE_NUMBER().object(const jni.JStringType()); + _id_EXTRA_PHONE_NUMBER.get(_class, const jni.JStringType()); - static final _get_EXTRA_PROCESS_TEXT = - jniLookup>( - "get_Intent__EXTRA_PROCESS_TEXT") - .asFunction(); + static final _id_EXTRA_PROCESS_TEXT = _class.staticFieldId( + r"EXTRA_PROCESS_TEXT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_PROCESS_TEXT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_PROCESS_TEXT => - _get_EXTRA_PROCESS_TEXT().object(const jni.JStringType()); + _id_EXTRA_PROCESS_TEXT.get(_class, const jni.JStringType()); - static final _get_EXTRA_PROCESS_TEXT_READONLY = - jniLookup>( - "get_Intent__EXTRA_PROCESS_TEXT_READONLY") - .asFunction(); + static final _id_EXTRA_PROCESS_TEXT_READONLY = _class.staticFieldId( + r"EXTRA_PROCESS_TEXT_READONLY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_PROCESS_TEXT_READONLY /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_PROCESS_TEXT_READONLY => - _get_EXTRA_PROCESS_TEXT_READONLY().object(const jni.JStringType()); + _id_EXTRA_PROCESS_TEXT_READONLY.get(_class, const jni.JStringType()); - static final _get_EXTRA_QUICK_VIEW_FEATURES = - jniLookup>( - "get_Intent__EXTRA_QUICK_VIEW_FEATURES") - .asFunction(); + static final _id_EXTRA_QUICK_VIEW_FEATURES = _class.staticFieldId( + r"EXTRA_QUICK_VIEW_FEATURES", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_QUICK_VIEW_FEATURES /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_QUICK_VIEW_FEATURES => - _get_EXTRA_QUICK_VIEW_FEATURES().object(const jni.JStringType()); + _id_EXTRA_QUICK_VIEW_FEATURES.get(_class, const jni.JStringType()); - static final _get_EXTRA_QUIET_MODE = - jniLookup>( - "get_Intent__EXTRA_QUIET_MODE") - .asFunction(); + static final _id_EXTRA_QUIET_MODE = _class.staticFieldId( + r"EXTRA_QUIET_MODE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_QUIET_MODE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_QUIET_MODE => - _get_EXTRA_QUIET_MODE().object(const jni.JStringType()); + _id_EXTRA_QUIET_MODE.get(_class, const jni.JStringType()); - static final _get_EXTRA_REFERRER = - jniLookup>( - "get_Intent__EXTRA_REFERRER") - .asFunction(); + static final _id_EXTRA_REFERRER = _class.staticFieldId( + r"EXTRA_REFERRER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_REFERRER /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_REFERRER => - _get_EXTRA_REFERRER().object(const jni.JStringType()); + _id_EXTRA_REFERRER.get(_class, const jni.JStringType()); - static final _get_EXTRA_REFERRER_NAME = - jniLookup>( - "get_Intent__EXTRA_REFERRER_NAME") - .asFunction(); + static final _id_EXTRA_REFERRER_NAME = _class.staticFieldId( + r"EXTRA_REFERRER_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_REFERRER_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_REFERRER_NAME => - _get_EXTRA_REFERRER_NAME().object(const jni.JStringType()); + _id_EXTRA_REFERRER_NAME.get(_class, const jni.JStringType()); - static final _get_EXTRA_REMOTE_INTENT_TOKEN = - jniLookup>( - "get_Intent__EXTRA_REMOTE_INTENT_TOKEN") - .asFunction(); + static final _id_EXTRA_REMOTE_INTENT_TOKEN = _class.staticFieldId( + r"EXTRA_REMOTE_INTENT_TOKEN", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_REMOTE_INTENT_TOKEN /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_REMOTE_INTENT_TOKEN => - _get_EXTRA_REMOTE_INTENT_TOKEN().object(const jni.JStringType()); + _id_EXTRA_REMOTE_INTENT_TOKEN.get(_class, const jni.JStringType()); - static final _get_EXTRA_REPLACEMENT_EXTRAS = - jniLookup>( - "get_Intent__EXTRA_REPLACEMENT_EXTRAS") - .asFunction(); + static final _id_EXTRA_REPLACEMENT_EXTRAS = _class.staticFieldId( + r"EXTRA_REPLACEMENT_EXTRAS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_REPLACEMENT_EXTRAS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_REPLACEMENT_EXTRAS => - _get_EXTRA_REPLACEMENT_EXTRAS().object(const jni.JStringType()); + _id_EXTRA_REPLACEMENT_EXTRAS.get(_class, const jni.JStringType()); - static final _get_EXTRA_REPLACING = - jniLookup>( - "get_Intent__EXTRA_REPLACING") - .asFunction(); + static final _id_EXTRA_REPLACING = _class.staticFieldId( + r"EXTRA_REPLACING", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_REPLACING /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_REPLACING => - _get_EXTRA_REPLACING().object(const jni.JStringType()); + _id_EXTRA_REPLACING.get(_class, const jni.JStringType()); - static final _get_EXTRA_RESTRICTIONS_BUNDLE = - jniLookup>( - "get_Intent__EXTRA_RESTRICTIONS_BUNDLE") - .asFunction(); + static final _id_EXTRA_RESTRICTIONS_BUNDLE = _class.staticFieldId( + r"EXTRA_RESTRICTIONS_BUNDLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_RESTRICTIONS_BUNDLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_RESTRICTIONS_BUNDLE => - _get_EXTRA_RESTRICTIONS_BUNDLE().object(const jni.JStringType()); + _id_EXTRA_RESTRICTIONS_BUNDLE.get(_class, const jni.JStringType()); - static final _get_EXTRA_RESTRICTIONS_INTENT = - jniLookup>( - "get_Intent__EXTRA_RESTRICTIONS_INTENT") - .asFunction(); + static final _id_EXTRA_RESTRICTIONS_INTENT = _class.staticFieldId( + r"EXTRA_RESTRICTIONS_INTENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_RESTRICTIONS_INTENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_RESTRICTIONS_INTENT => - _get_EXTRA_RESTRICTIONS_INTENT().object(const jni.JStringType()); + _id_EXTRA_RESTRICTIONS_INTENT.get(_class, const jni.JStringType()); - static final _get_EXTRA_RESTRICTIONS_LIST = - jniLookup>( - "get_Intent__EXTRA_RESTRICTIONS_LIST") - .asFunction(); + static final _id_EXTRA_RESTRICTIONS_LIST = _class.staticFieldId( + r"EXTRA_RESTRICTIONS_LIST", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_RESTRICTIONS_LIST /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_RESTRICTIONS_LIST => - _get_EXTRA_RESTRICTIONS_LIST().object(const jni.JStringType()); + _id_EXTRA_RESTRICTIONS_LIST.get(_class, const jni.JStringType()); - static final _get_EXTRA_RESULT_RECEIVER = - jniLookup>( - "get_Intent__EXTRA_RESULT_RECEIVER") - .asFunction(); + static final _id_EXTRA_RESULT_RECEIVER = _class.staticFieldId( + r"EXTRA_RESULT_RECEIVER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_RESULT_RECEIVER /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_RESULT_RECEIVER => - _get_EXTRA_RESULT_RECEIVER().object(const jni.JStringType()); + _id_EXTRA_RESULT_RECEIVER.get(_class, const jni.JStringType()); - static final _get_EXTRA_RETURN_RESULT = - jniLookup>( - "get_Intent__EXTRA_RETURN_RESULT") - .asFunction(); + static final _id_EXTRA_RETURN_RESULT = _class.staticFieldId( + r"EXTRA_RETURN_RESULT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_RETURN_RESULT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_RETURN_RESULT => - _get_EXTRA_RETURN_RESULT().object(const jni.JStringType()); + _id_EXTRA_RETURN_RESULT.get(_class, const jni.JStringType()); - static final _get_EXTRA_SHORTCUT_ICON = - jniLookup>( - "get_Intent__EXTRA_SHORTCUT_ICON") - .asFunction(); + static final _id_EXTRA_SHORTCUT_ICON = _class.staticFieldId( + r"EXTRA_SHORTCUT_ICON", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SHORTCUT_ICON /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SHORTCUT_ICON => - _get_EXTRA_SHORTCUT_ICON().object(const jni.JStringType()); + _id_EXTRA_SHORTCUT_ICON.get(_class, const jni.JStringType()); - static final _get_EXTRA_SHORTCUT_ICON_RESOURCE = - jniLookup>( - "get_Intent__EXTRA_SHORTCUT_ICON_RESOURCE") - .asFunction(); + static final _id_EXTRA_SHORTCUT_ICON_RESOURCE = _class.staticFieldId( + r"EXTRA_SHORTCUT_ICON_RESOURCE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SHORTCUT_ICON_RESOURCE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SHORTCUT_ICON_RESOURCE => - _get_EXTRA_SHORTCUT_ICON_RESOURCE().object(const jni.JStringType()); + _id_EXTRA_SHORTCUT_ICON_RESOURCE.get(_class, const jni.JStringType()); - static final _get_EXTRA_SHORTCUT_ID = - jniLookup>( - "get_Intent__EXTRA_SHORTCUT_ID") - .asFunction(); + static final _id_EXTRA_SHORTCUT_ID = _class.staticFieldId( + r"EXTRA_SHORTCUT_ID", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SHORTCUT_ID /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SHORTCUT_ID => - _get_EXTRA_SHORTCUT_ID().object(const jni.JStringType()); + _id_EXTRA_SHORTCUT_ID.get(_class, const jni.JStringType()); - static final _get_EXTRA_SHORTCUT_INTENT = - jniLookup>( - "get_Intent__EXTRA_SHORTCUT_INTENT") - .asFunction(); + static final _id_EXTRA_SHORTCUT_INTENT = _class.staticFieldId( + r"EXTRA_SHORTCUT_INTENT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SHORTCUT_INTENT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SHORTCUT_INTENT => - _get_EXTRA_SHORTCUT_INTENT().object(const jni.JStringType()); + _id_EXTRA_SHORTCUT_INTENT.get(_class, const jni.JStringType()); - static final _get_EXTRA_SHORTCUT_NAME = - jniLookup>( - "get_Intent__EXTRA_SHORTCUT_NAME") - .asFunction(); + static final _id_EXTRA_SHORTCUT_NAME = _class.staticFieldId( + r"EXTRA_SHORTCUT_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SHORTCUT_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SHORTCUT_NAME => - _get_EXTRA_SHORTCUT_NAME().object(const jni.JStringType()); + _id_EXTRA_SHORTCUT_NAME.get(_class, const jni.JStringType()); - static final _get_EXTRA_SHUTDOWN_USERSPACE_ONLY = - jniLookup>( - "get_Intent__EXTRA_SHUTDOWN_USERSPACE_ONLY") - .asFunction(); + static final _id_EXTRA_SHUTDOWN_USERSPACE_ONLY = _class.staticFieldId( + r"EXTRA_SHUTDOWN_USERSPACE_ONLY", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SHUTDOWN_USERSPACE_ONLY /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SHUTDOWN_USERSPACE_ONLY => - _get_EXTRA_SHUTDOWN_USERSPACE_ONLY().object(const jni.JStringType()); + _id_EXTRA_SHUTDOWN_USERSPACE_ONLY.get(_class, const jni.JStringType()); - static final _get_EXTRA_SPLIT_NAME = - jniLookup>( - "get_Intent__EXTRA_SPLIT_NAME") - .asFunction(); + static final _id_EXTRA_SPLIT_NAME = _class.staticFieldId( + r"EXTRA_SPLIT_NAME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SPLIT_NAME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SPLIT_NAME => - _get_EXTRA_SPLIT_NAME().object(const jni.JStringType()); + _id_EXTRA_SPLIT_NAME.get(_class, const jni.JStringType()); - static final _get_EXTRA_START_TIME = - jniLookup>( - "get_Intent__EXTRA_START_TIME") - .asFunction(); + static final _id_EXTRA_START_TIME = _class.staticFieldId( + r"EXTRA_START_TIME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_START_TIME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_START_TIME => - _get_EXTRA_START_TIME().object(const jni.JStringType()); + _id_EXTRA_START_TIME.get(_class, const jni.JStringType()); - static final _get_EXTRA_STREAM = - jniLookup>( - "get_Intent__EXTRA_STREAM") - .asFunction(); + static final _id_EXTRA_STREAM = _class.staticFieldId( + r"EXTRA_STREAM", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_STREAM /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_STREAM => - _get_EXTRA_STREAM().object(const jni.JStringType()); + _id_EXTRA_STREAM.get(_class, const jni.JStringType()); - static final _get_EXTRA_SUBJECT = - jniLookup>( - "get_Intent__EXTRA_SUBJECT") - .asFunction(); + static final _id_EXTRA_SUBJECT = _class.staticFieldId( + r"EXTRA_SUBJECT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SUBJECT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SUBJECT => - _get_EXTRA_SUBJECT().object(const jni.JStringType()); + _id_EXTRA_SUBJECT.get(_class, const jni.JStringType()); - static final _get_EXTRA_SUSPENDED_PACKAGE_EXTRAS = - jniLookup>( - "get_Intent__EXTRA_SUSPENDED_PACKAGE_EXTRAS") - .asFunction(); + static final _id_EXTRA_SUSPENDED_PACKAGE_EXTRAS = _class.staticFieldId( + r"EXTRA_SUSPENDED_PACKAGE_EXTRAS", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_SUSPENDED_PACKAGE_EXTRAS /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_SUSPENDED_PACKAGE_EXTRAS => - _get_EXTRA_SUSPENDED_PACKAGE_EXTRAS().object(const jni.JStringType()); + _id_EXTRA_SUSPENDED_PACKAGE_EXTRAS.get(_class, const jni.JStringType()); - static final _get_EXTRA_TEMPLATE = - jniLookup>( - "get_Intent__EXTRA_TEMPLATE") - .asFunction(); + static final _id_EXTRA_TEMPLATE = _class.staticFieldId( + r"EXTRA_TEMPLATE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_TEMPLATE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_TEMPLATE => - _get_EXTRA_TEMPLATE().object(const jni.JStringType()); + _id_EXTRA_TEMPLATE.get(_class, const jni.JStringType()); - static final _get_EXTRA_TEXT = - jniLookup>( - "get_Intent__EXTRA_TEXT") - .asFunction(); + static final _id_EXTRA_TEXT = _class.staticFieldId( + r"EXTRA_TEXT", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_TEXT /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_TEXT => - _get_EXTRA_TEXT().object(const jni.JStringType()); + _id_EXTRA_TEXT.get(_class, const jni.JStringType()); - static final _get_EXTRA_TIME = - jniLookup>( - "get_Intent__EXTRA_TIME") - .asFunction(); + static final _id_EXTRA_TIME = _class.staticFieldId( + r"EXTRA_TIME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_TIME /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_TIME => - _get_EXTRA_TIME().object(const jni.JStringType()); + _id_EXTRA_TIME.get(_class, const jni.JStringType()); - static final _get_EXTRA_TIMEZONE = - jniLookup>( - "get_Intent__EXTRA_TIMEZONE") - .asFunction(); + static final _id_EXTRA_TIMEZONE = _class.staticFieldId( + r"EXTRA_TIMEZONE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_TIMEZONE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_TIMEZONE => - _get_EXTRA_TIMEZONE().object(const jni.JStringType()); + _id_EXTRA_TIMEZONE.get(_class, const jni.JStringType()); - static final _get_EXTRA_TITLE = - jniLookup>( - "get_Intent__EXTRA_TITLE") - .asFunction(); + static final _id_EXTRA_TITLE = _class.staticFieldId( + r"EXTRA_TITLE", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_TITLE /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_TITLE => - _get_EXTRA_TITLE().object(const jni.JStringType()); + _id_EXTRA_TITLE.get(_class, const jni.JStringType()); - static final _get_EXTRA_UID = - jniLookup>( - "get_Intent__EXTRA_UID") - .asFunction(); + static final _id_EXTRA_UID = _class.staticFieldId( + r"EXTRA_UID", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_UID /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_UID => - _get_EXTRA_UID().object(const jni.JStringType()); + _id_EXTRA_UID.get(_class, const jni.JStringType()); - static final _get_EXTRA_USER = - jniLookup>( - "get_Intent__EXTRA_USER") - .asFunction(); + static final _id_EXTRA_USER = _class.staticFieldId( + r"EXTRA_USER", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_USER /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_USER => - _get_EXTRA_USER().object(const jni.JStringType()); + _id_EXTRA_USER.get(_class, const jni.JStringType()); - static final _get_EXTRA_USER_INITIATED = - jniLookup>( - "get_Intent__EXTRA_USER_INITIATED") - .asFunction(); + static final _id_EXTRA_USER_INITIATED = _class.staticFieldId( + r"EXTRA_USER_INITIATED", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String EXTRA_USER_INITIATED /// The returned object must be released after use, by calling the [release] method. static jni.JString get EXTRA_USER_INITIATED => - _get_EXTRA_USER_INITIATED().object(const jni.JStringType()); + _id_EXTRA_USER_INITIATED.get(_class, const jni.JStringType()); /// from: static public final int FILL_IN_ACTION static const FILL_IN_ACTION = 1; @@ -8277,15 +10702,15 @@ class Intent extends jni.JObject { /// from: static public final int FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS static const FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS = 2097152; - static final _get_METADATA_DOCK_HOME = - jniLookup>( - "get_Intent__METADATA_DOCK_HOME") - .asFunction(); + static final _id_METADATA_DOCK_HOME = _class.staticFieldId( + r"METADATA_DOCK_HOME", + r"Ljava/lang/String;", + ); /// from: static public final java.lang.String METADATA_DOCK_HOME /// The returned object must be released after use, by calling the [release] method. static jni.JString get METADATA_DOCK_HOME => - _get_METADATA_DOCK_HOME().object(const jni.JStringType()); + _id_METADATA_DOCK_HOME.get(_class, const jni.JStringType()); /// from: static public final int URI_ALLOW_UNSAFE static const URI_ALLOW_UNSAFE = 4; @@ -8295,48 +10720,96 @@ class Intent extends jni.JObject { /// from: static public final int URI_INTENT_SCHEME static const URI_INTENT_SCHEME = 1; - static final _new0 = - jniLookup>("Intent__new0") - .asFunction(); + static final _id_new0 = _class.constructorId( + r"()V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_NewObject") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void () /// The returned object must be released after use, by calling the [release] method. factory Intent() { - return Intent.fromReference(_new0().reference); + return Intent.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); } - static final _new1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Intent__new1") - .asFunction)>(); + static final _id_new1 = _class.constructorId( + r"(Landroid/content/Intent;)V", + ); + + static final _new1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_NewObject") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void (android.content.Intent intent) /// The returned object must be released after use, by calling the [release] method. factory Intent.new1( Intent intent, ) { - return Intent.fromReference(_new1(intent.reference.pointer).reference); + return Intent.fromReference(_new1(_class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, intent.reference.pointer) + .reference); } - static final _new2 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Intent__new2") - .asFunction)>(); + static final _id_new2 = _class.constructorId( + r"(Ljava/lang/String;)V", + ); + + static final _new2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_NewObject") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void (java.lang.String string) /// The returned object must be released after use, by calling the [release] method. factory Intent.new2( jni.JString string, ) { - return Intent.fromReference(_new2(string.reference.pointer).reference); + return Intent.fromReference(_new2(_class.reference.pointer, + _id_new2 as jni.JMethodIDPtr, string.reference.pointer) + .reference); } - static final _new3 = jniLookup< + static final _id_new3 = _class.constructorId( + r"(Ljava/lang/String;Landroid/net/Uri;)V", + ); + + static final _new3 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__new3") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: public void (java.lang.String string, android.net.Uri uri) @@ -8345,16 +10818,30 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject uri, ) { - return Intent.fromReference( - _new3(string.reference.pointer, uri.reference.pointer).reference); + return Intent.fromReference(_new3( + _class.reference.pointer, + _id_new3 as jni.JMethodIDPtr, + string.reference.pointer, + uri.reference.pointer) + .reference); } - static final _new4 = jniLookup< + static final _id_new4 = _class.constructorId( + r"(Landroid/content/Context;Ljava/lang/Class;)V", + ); + + static final _new4 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__new4") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: public void (android.content.Context context, java.lang.Class class) @@ -8363,20 +10850,38 @@ class Intent extends jni.JObject { Context context, jni.JObject class0, ) { - return Intent.fromReference( - _new4(context.reference.pointer, class0.reference.pointer).reference); + return Intent.fromReference(_new4( + _class.reference.pointer, + _id_new4 as jni.JMethodIDPtr, + context.reference.pointer, + class0.reference.pointer) + .reference); } - static final _new5 = jniLookup< + static final _id_new5 = _class.constructorId( + r"(Ljava/lang/String;Landroid/net/Uri;Landroid/content/Context;Ljava/lang/Class;)V", + ); + + static final _new5 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__new5") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public void (java.lang.String string, android.net.Uri uri, android.content.Context context, java.lang.Class class) /// The returned object must be released after use, by calling the [release] method. @@ -8387,6 +10892,8 @@ class Intent extends jni.JObject { jni.JObject class0, ) { return Intent.fromReference(_new5( + _class.reference.pointer, + _id_new5 as jni.JMethodIDPtr, string.reference.pointer, uri.reference.pointer, context.reference.pointer, @@ -8394,12 +10901,23 @@ class Intent extends jni.JObject { .reference); } - static final _createChooser = jniLookup< + static final _id_createChooser = _class.staticMethodId( + r"createChooser", + r"(Landroid/content/Intent;Ljava/lang/CharSequence;)Landroid/content/Intent;", + ); + + static final _createChooser = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__createChooser") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallStaticObjectMethod") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: static public android.content.Intent createChooser(android.content.Intent intent, java.lang.CharSequence charSequence) @@ -8409,18 +10927,35 @@ class Intent extends jni.JObject { jni.JObject charSequence, ) { return _createChooser( - intent.reference.pointer, charSequence.reference.pointer) + _class.reference.pointer, + _id_createChooser as jni.JMethodIDPtr, + intent.reference.pointer, + charSequence.reference.pointer) .object(const $IntentType()); } - static final _createChooser1 = jniLookup< + static final _id_createChooser1 = _class.staticMethodId( + r"createChooser", + r"(Landroid/content/Intent;Ljava/lang/CharSequence;Landroid/content/IntentSender;)Landroid/content/Intent;", + ); + + static final _createChooser1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__createChooser1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallStaticObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); /// from: static public android.content.Intent createChooser(android.content.Intent intent, java.lang.CharSequence charSequence, android.content.IntentSender intentSender) @@ -8430,55 +10965,108 @@ class Intent extends jni.JObject { jni.JObject charSequence, jni.JObject intentSender, ) { - return _createChooser1(intent.reference.pointer, - charSequence.reference.pointer, intentSender.reference.pointer) + return _createChooser1( + _class.reference.pointer, + _id_createChooser1 as jni.JMethodIDPtr, + intent.reference.pointer, + charSequence.reference.pointer, + intentSender.reference.pointer) .object(const $IntentType()); } - static final _clone = jniLookup< + static final _id_clone = _class.instanceMethodId( + r"clone", + r"()Ljava/lang/Object;", + ); + + static final _clone = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Intent__clone") - .asFunction)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.Object clone() /// The returned object must be released after use, by calling the [release] method. jni.JObject clone() { - return _clone(reference.pointer).object(const jni.JObjectType()); + return _clone(reference.pointer, _id_clone as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _cloneFilter = jniLookup< - ffi - .NativeFunction)>>( - "Intent__cloneFilter") - .asFunction)>(); + static final _id_cloneFilter = _class.instanceMethodId( + r"cloneFilter", + r"()Landroid/content/Intent;", + ); + + static final _cloneFilter = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.Intent cloneFilter() /// The returned object must be released after use, by calling the [release] method. Intent cloneFilter() { - return _cloneFilter(reference.pointer).object(const $IntentType()); + return _cloneFilter(reference.pointer, _id_cloneFilter as jni.JMethodIDPtr) + .object(const $IntentType()); } - static final _makeMainActivity = jniLookup< - ffi - .NativeFunction)>>( - "Intent__makeMainActivity") - .asFunction)>(); + static final _id_makeMainActivity = _class.staticMethodId( + r"makeMainActivity", + r"(Landroid/content/ComponentName;)Landroid/content/Intent;", + ); + + static final _makeMainActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public android.content.Intent makeMainActivity(android.content.ComponentName componentName) /// The returned object must be released after use, by calling the [release] method. static Intent makeMainActivity( jni.JObject componentName, ) { - return _makeMainActivity(componentName.reference.pointer) + return _makeMainActivity( + _class.reference.pointer, + _id_makeMainActivity as jni.JMethodIDPtr, + componentName.reference.pointer) .object(const $IntentType()); } - static final _makeMainSelectorActivity = jniLookup< + static final _id_makeMainSelectorActivity = _class.staticMethodId( + r"makeMainSelectorActivity", + r"(Ljava/lang/String;Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _makeMainSelectorActivity = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__makeMainSelectorActivity") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallStaticObjectMethod") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: static public android.content.Intent makeMainSelectorActivity(java.lang.String string, java.lang.String string1) @@ -8488,44 +11076,82 @@ class Intent extends jni.JObject { jni.JString string1, ) { return _makeMainSelectorActivity( - string.reference.pointer, string1.reference.pointer) + _class.reference.pointer, + _id_makeMainSelectorActivity as jni.JMethodIDPtr, + string.reference.pointer, + string1.reference.pointer) .object(const $IntentType()); } - static final _makeRestartActivityTask = jniLookup< - ffi - .NativeFunction)>>( - "Intent__makeRestartActivityTask") - .asFunction)>(); + static final _id_makeRestartActivityTask = _class.staticMethodId( + r"makeRestartActivityTask", + r"(Landroid/content/ComponentName;)Landroid/content/Intent;", + ); + + static final _makeRestartActivityTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public android.content.Intent makeRestartActivityTask(android.content.ComponentName componentName) /// The returned object must be released after use, by calling the [release] method. static Intent makeRestartActivityTask( jni.JObject componentName, ) { - return _makeRestartActivityTask(componentName.reference.pointer) + return _makeRestartActivityTask( + _class.reference.pointer, + _id_makeRestartActivityTask as jni.JMethodIDPtr, + componentName.reference.pointer) .object(const $IntentType()); } - static final _getIntent = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getIntent") - .asFunction)>(); + static final _id_getIntent = _class.staticMethodId( + r"getIntent", + r"(Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _getIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public android.content.Intent getIntent(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. static Intent getIntent( jni.JString string, ) { - return _getIntent(string.reference.pointer).object(const $IntentType()); + return _getIntent(_class.reference.pointer, + _id_getIntent as jni.JMethodIDPtr, string.reference.pointer) + .object(const $IntentType()); } - static final _parseUri = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Intent__parseUri") - .asFunction, int)>(); + static final _id_parseUri = _class.staticMethodId( + r"parseUri", + r"(Ljava/lang/String;I)Landroid/content/Intent;", + ); + + static final _parseUri = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: static public android.content.Intent parseUri(java.lang.String string, int i) /// The returned object must be released after use, by calling the [release] method. @@ -8533,122 +11159,227 @@ class Intent extends jni.JObject { jni.JString string, int i, ) { - return _parseUri(string.reference.pointer, i).object(const $IntentType()); + return _parseUri(_class.reference.pointer, _id_parseUri as jni.JMethodIDPtr, + string.reference.pointer, i) + .object(const $IntentType()); } - static final _getIntentOld = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getIntentOld") - .asFunction)>(); + static final _id_getIntentOld = _class.staticMethodId( + r"getIntentOld", + r"(Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _getIntentOld = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public android.content.Intent getIntentOld(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. static Intent getIntentOld( jni.JString string, ) { - return _getIntentOld(string.reference.pointer).object(const $IntentType()); + return _getIntentOld(_class.reference.pointer, + _id_getIntentOld as jni.JMethodIDPtr, string.reference.pointer) + .object(const $IntentType()); } - static final _getAction = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getAction") - .asFunction)>(); + static final _id_getAction = _class.instanceMethodId( + r"getAction", + r"()Ljava/lang/String;", + ); + + static final _getAction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getAction() /// The returned object must be released after use, by calling the [release] method. jni.JString getAction() { - return _getAction(reference.pointer).object(const jni.JStringType()); + return _getAction(reference.pointer, _id_getAction as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _getData = jniLookup< + static final _id_getData = _class.instanceMethodId( + r"getData", + r"()Landroid/net/Uri;", + ); + + static final _getData = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Intent__getData") - .asFunction)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.net.Uri getData() /// The returned object must be released after use, by calling the [release] method. jni.JObject getData() { - return _getData(reference.pointer).object(const jni.JObjectType()); + return _getData(reference.pointer, _id_getData as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getDataString = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getDataString") - .asFunction)>(); + static final _id_getDataString = _class.instanceMethodId( + r"getDataString", + r"()Ljava/lang/String;", + ); + + static final _getDataString = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getDataString() /// The returned object must be released after use, by calling the [release] method. jni.JString getDataString() { - return _getDataString(reference.pointer).object(const jni.JStringType()); + return _getDataString( + reference.pointer, _id_getDataString as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _getScheme = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getScheme") - .asFunction)>(); + static final _id_getScheme = _class.instanceMethodId( + r"getScheme", + r"()Ljava/lang/String;", + ); + + static final _getScheme = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getScheme() /// The returned object must be released after use, by calling the [release] method. jni.JString getScheme() { - return _getScheme(reference.pointer).object(const jni.JStringType()); + return _getScheme(reference.pointer, _id_getScheme as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _getType = jniLookup< + static final _id_getType = _class.instanceMethodId( + r"getType", + r"()Ljava/lang/String;", + ); + + static final _getType = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Intent__getType") - .asFunction)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getType() /// The returned object must be released after use, by calling the [release] method. jni.JString getType() { - return _getType(reference.pointer).object(const jni.JStringType()); + return _getType(reference.pointer, _id_getType as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _resolveType = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__resolveType") + static final _id_resolveType = _class.instanceMethodId( + r"resolveType", + r"(Landroid/content/Context;)Ljava/lang/String;", + ); + + static final _resolveType = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.lang.String resolveType(android.content.Context context) /// The returned object must be released after use, by calling the [release] method. jni.JString resolveType( Context context, ) { - return _resolveType(reference.pointer, context.reference.pointer) + return _resolveType(reference.pointer, _id_resolveType as jni.JMethodIDPtr, + context.reference.pointer) .object(const jni.JStringType()); } - static final _resolveType1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__resolveType1") + static final _id_resolveType1 = _class.instanceMethodId( + r"resolveType", + r"(Landroid/content/ContentResolver;)Ljava/lang/String;", + ); + + static final _resolveType1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.lang.String resolveType(android.content.ContentResolver contentResolver) /// The returned object must be released after use, by calling the [release] method. jni.JString resolveType1( jni.JObject contentResolver, ) { - return _resolveType1(reference.pointer, contentResolver.reference.pointer) + return _resolveType1( + reference.pointer, + _id_resolveType1 as jni.JMethodIDPtr, + contentResolver.reference.pointer) .object(const jni.JStringType()); } - static final _resolveTypeIfNeeded = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__resolveTypeIfNeeded") + static final _id_resolveTypeIfNeeded = _class.instanceMethodId( + r"resolveTypeIfNeeded", + r"(Landroid/content/ContentResolver;)Ljava/lang/String;", + ); + + static final _resolveTypeIfNeeded = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.lang.String resolveTypeIfNeeded(android.content.ContentResolver contentResolver) /// The returned object must be released after use, by calling the [release] method. @@ -8656,123 +11387,226 @@ class Intent extends jni.JObject { jni.JObject contentResolver, ) { return _resolveTypeIfNeeded( - reference.pointer, contentResolver.reference.pointer) + reference.pointer, + _id_resolveTypeIfNeeded as jni.JMethodIDPtr, + contentResolver.reference.pointer) .object(const jni.JStringType()); } - static final _getIdentifier = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getIdentifier") - .asFunction)>(); + static final _id_getIdentifier = _class.instanceMethodId( + r"getIdentifier", + r"()Ljava/lang/String;", + ); + + static final _getIdentifier = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getIdentifier() /// The returned object must be released after use, by calling the [release] method. jni.JString getIdentifier() { - return _getIdentifier(reference.pointer).object(const jni.JStringType()); + return _getIdentifier( + reference.pointer, _id_getIdentifier as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _hasCategory = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__hasCategory") + static final _id_hasCategory = _class.instanceMethodId( + r"hasCategory", + r"(Ljava/lang/String;)Z", + ); + + static final _hasCategory = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean hasCategory(java.lang.String string) bool hasCategory( jni.JString string, ) { - return _hasCategory(reference.pointer, string.reference.pointer).boolean; + return _hasCategory(reference.pointer, _id_hasCategory as jni.JMethodIDPtr, + string.reference.pointer) + .boolean; } - static final _getCategories = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getCategories") - .asFunction)>(); + static final _id_getCategories = _class.instanceMethodId( + r"getCategories", + r"()Ljava/util/Set;", + ); + + static final _getCategories = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.util.Set getCategories() /// The returned object must be released after use, by calling the [release] method. jni.JSet getCategories() { - return _getCategories(reference.pointer) + return _getCategories( + reference.pointer, _id_getCategories as jni.JMethodIDPtr) .object(const jni.JSetType(jni.JStringType())); } - static final _getSelector = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getSelector") - .asFunction)>(); + static final _id_getSelector = _class.instanceMethodId( + r"getSelector", + r"()Landroid/content/Intent;", + ); + + static final _getSelector = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.Intent getSelector() /// The returned object must be released after use, by calling the [release] method. Intent getSelector() { - return _getSelector(reference.pointer).object(const $IntentType()); + return _getSelector(reference.pointer, _id_getSelector as jni.JMethodIDPtr) + .object(const $IntentType()); } - static final _getClipData = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getClipData") - .asFunction)>(); + static final _id_getClipData = _class.instanceMethodId( + r"getClipData", + r"()Landroid/content/ClipData;", + ); + + static final _getClipData = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.ClipData getClipData() /// The returned object must be released after use, by calling the [release] method. jni.JObject getClipData() { - return _getClipData(reference.pointer).object(const jni.JObjectType()); + return _getClipData(reference.pointer, _id_getClipData as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _setExtrasClassLoader = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setExtrasClassLoader") + static final _id_setExtrasClassLoader = _class.instanceMethodId( + r"setExtrasClassLoader", + r"(Ljava/lang/ClassLoader;)V", + ); + + static final _setExtrasClassLoader = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setExtrasClassLoader(java.lang.ClassLoader classLoader) void setExtrasClassLoader( jni.JObject classLoader, ) { - _setExtrasClassLoader(reference.pointer, classLoader.reference.pointer) + _setExtrasClassLoader( + reference.pointer, + _id_setExtrasClassLoader as jni.JMethodIDPtr, + classLoader.reference.pointer) .check(); } - static final _hasExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__hasExtra") + static final _id_hasExtra = _class.instanceMethodId( + r"hasExtra", + r"(Ljava/lang/String;)Z", + ); + + static final _hasExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean hasExtra(java.lang.String string) bool hasExtra( jni.JString string, ) { - return _hasExtra(reference.pointer, string.reference.pointer).boolean; + return _hasExtra(reference.pointer, _id_hasExtra as jni.JMethodIDPtr, + string.reference.pointer) + .boolean; } - static final _hasFileDescriptors = jniLookup< - ffi - .NativeFunction)>>( - "Intent__hasFileDescriptors") - .asFunction)>(); + static final _id_hasFileDescriptors = _class.instanceMethodId( + r"hasFileDescriptors", + r"()Z", + ); + + static final _hasFileDescriptors = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean hasFileDescriptors() bool hasFileDescriptors() { - return _hasFileDescriptors(reference.pointer).boolean; + return _hasFileDescriptors( + reference.pointer, _id_hasFileDescriptors as jni.JMethodIDPtr) + .boolean; } - static final _getBooleanExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Uint8)>>("Intent__getBooleanExtra") + static final _id_getBooleanExtra = _class.instanceMethodId( + r"getBooleanExtra", + r"(Ljava/lang/String;Z)Z", + ); + + static final _getBooleanExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public boolean getBooleanExtra(java.lang.String string, boolean z) bool getBooleanExtra( @@ -8780,164 +11614,264 @@ class Intent extends jni.JObject { bool z, ) { return _getBooleanExtra( - reference.pointer, string.reference.pointer, z ? 1 : 0) + reference.pointer, + _id_getBooleanExtra as jni.JMethodIDPtr, + string.reference.pointer, + z ? 1 : 0) .boolean; } - static final _getByteExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int8)>>("Intent__getByteExtra") + static final _id_getByteExtra = _class.instanceMethodId( + r"getByteExtra", + r"(Ljava/lang/String;B)B", + ); + + static final _getByteExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallByteMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public byte getByteExtra(java.lang.String string, byte b) int getByteExtra( jni.JString string, int b, ) { - return _getByteExtra(reference.pointer, string.reference.pointer, b).byte; + return _getByteExtra(reference.pointer, + _id_getByteExtra as jni.JMethodIDPtr, string.reference.pointer, b) + .byte; } - static final _getShortExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int16)>>("Intent__getShortExtra") + static final _id_getShortExtra = _class.instanceMethodId( + r"getShortExtra", + r"(Ljava/lang/String;S)S", + ); + + static final _getShortExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallShortMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public short getShortExtra(java.lang.String string, short s) int getShortExtra( jni.JString string, int s, ) { - return _getShortExtra(reference.pointer, string.reference.pointer, s).short; + return _getShortExtra(reference.pointer, + _id_getShortExtra as jni.JMethodIDPtr, string.reference.pointer, s) + .short; } - static final _getCharExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Uint16)>>("Intent__getCharExtra") + static final _id_getCharExtra = _class.instanceMethodId( + r"getCharExtra", + r"(Ljava/lang/String;C)C", + ); + + static final _getCharExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallCharMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public char getCharExtra(java.lang.String string, char c) int getCharExtra( jni.JString string, int c, ) { - return _getCharExtra(reference.pointer, string.reference.pointer, c).char; + return _getCharExtra(reference.pointer, + _id_getCharExtra as jni.JMethodIDPtr, string.reference.pointer, c) + .char; } - static final _getIntExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int32)>>("Intent__getIntExtra") + static final _id_getIntExtra = _class.instanceMethodId( + r"getIntExtra", + r"(Ljava/lang/String;I)I", + ); + + static final _getIntExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public int getIntExtra(java.lang.String string, int i) int getIntExtra( jni.JString string, int i, ) { - return _getIntExtra(reference.pointer, string.reference.pointer, i).integer; + return _getIntExtra(reference.pointer, _id_getIntExtra as jni.JMethodIDPtr, + string.reference.pointer, i) + .integer; } - static final _getLongExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int64)>>("Intent__getLongExtra") + static final _id_getLongExtra = _class.instanceMethodId( + r"getLongExtra", + r"(Ljava/lang/String;J)J", + ); + + static final _getLongExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallLongMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public long getLongExtra(java.lang.String string, long j) int getLongExtra( jni.JString string, int j, ) { - return _getLongExtra(reference.pointer, string.reference.pointer, j).long; + return _getLongExtra(reference.pointer, + _id_getLongExtra as jni.JMethodIDPtr, string.reference.pointer, j) + .long; } - static final _getFloatExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Float)>>("Intent__getFloatExtra") + static final _id_getFloatExtra = _class.instanceMethodId( + r"getFloatExtra", + r"(Ljava/lang/String;F)F", + ); + + static final _getFloatExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Double)>)>>( + "globalEnv_CallFloatMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, double)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, double)>(); /// from: public float getFloatExtra(java.lang.String string, float f) double getFloatExtra( jni.JString string, double f, ) { - return _getFloatExtra(reference.pointer, string.reference.pointer, f).float; + return _getFloatExtra(reference.pointer, + _id_getFloatExtra as jni.JMethodIDPtr, string.reference.pointer, f) + .float; } - static final _getDoubleExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Double)>>("Intent__getDoubleExtra") + static final _id_getDoubleExtra = _class.instanceMethodId( + r"getDoubleExtra", + r"(Ljava/lang/String;D)D", + ); + + static final _getDoubleExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Double)>)>>( + "globalEnv_CallDoubleMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, double)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, double)>(); /// from: public double getDoubleExtra(java.lang.String string, double d) double getDoubleExtra( jni.JString string, double d, ) { - return _getDoubleExtra(reference.pointer, string.reference.pointer, d) + return _getDoubleExtra(reference.pointer, + _id_getDoubleExtra as jni.JMethodIDPtr, string.reference.pointer, d) .doubleFloat; } - static final _getStringExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getStringExtra") + static final _id_getStringExtra = _class.instanceMethodId( + r"getStringExtra", + r"(Ljava/lang/String;)Ljava/lang/String;", + ); + + static final _getStringExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.lang.String getStringExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JString getStringExtra( jni.JString string, ) { - return _getStringExtra(reference.pointer, string.reference.pointer) + return _getStringExtra(reference.pointer, + _id_getStringExtra as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JStringType()); } - static final _getCharSequenceExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getCharSequenceExtra") + static final _id_getCharSequenceExtra = _class.instanceMethodId( + r"getCharSequenceExtra", + r"(Ljava/lang/String;)Ljava/lang/CharSequence;", + ); + + static final _getCharSequenceExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.lang.CharSequence getCharSequenceExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getCharSequenceExtra( jni.JString string, ) { - return _getCharSequenceExtra(reference.pointer, string.reference.pointer) + return _getCharSequenceExtra( + reference.pointer, + _id_getCharSequenceExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _getParcelableExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getParcelableExtra") + static final _id_getParcelableExtra = _class.instanceMethodId( + r"getParcelableExtra", + r"(Ljava/lang/String;)Landroid/os/Parcelable;", + ); + + static final _getParcelableExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public T getParcelableExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -8945,19 +11879,31 @@ class Intent extends jni.JObject { jni.JString string, { required jni.JObjType<$T> T, }) { - return _getParcelableExtra(reference.pointer, string.reference.pointer) + return _getParcelableExtra( + reference.pointer, + _id_getParcelableExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(T); } - static final _getParcelableExtra1 = jniLookup< + static final _id_getParcelableExtra1 = _class.instanceMethodId( + r"getParcelableExtra", + r"(Ljava/lang/String;Ljava/lang/Class;)Ljava/lang/Object;", + ); + + static final _getParcelableExtra1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__getParcelableExtra1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public T getParcelableExtra(java.lang.String string, java.lang.Class class) /// The returned object must be released after use, by calling the [release] method. @@ -8966,37 +11912,60 @@ class Intent extends jni.JObject { jni.JObject class0, { required jni.JObjType<$T> T, }) { - return _getParcelableExtra1(reference.pointer, string.reference.pointer, + return _getParcelableExtra1( + reference.pointer, + _id_getParcelableExtra1 as jni.JMethodIDPtr, + string.reference.pointer, class0.reference.pointer) .object(T); } - static final _getParcelableArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getParcelableArrayExtra") + static final _id_getParcelableArrayExtra = _class.instanceMethodId( + r"getParcelableArrayExtra", + r"(Ljava/lang/String;)[Landroid/os/Parcelable;", + ); + + static final _getParcelableArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.os.Parcelable[] getParcelableArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getParcelableArrayExtra( jni.JString string, ) { - return _getParcelableArrayExtra(reference.pointer, string.reference.pointer) + return _getParcelableArrayExtra( + reference.pointer, + _id_getParcelableArrayExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JArrayType(jni.JObjectType())); } - static final _getParcelableArrayExtra1 = jniLookup< + static final _id_getParcelableArrayExtra1 = _class.instanceMethodId( + r"getParcelableArrayExtra", + r"(Ljava/lang/String;Ljava/lang/Class;)[Ljava/lang/Object;", + ); + + static final _getParcelableArrayExtra1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__getParcelableArrayExtra1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public java.lang.Object[] getParcelableArrayExtra(java.lang.String string, java.lang.Class class) /// The returned object must be released after use, by calling the [release] method. @@ -9005,19 +11974,29 @@ class Intent extends jni.JObject { jni.JObject class0, { required jni.JObjType<$T> T, }) { - return _getParcelableArrayExtra1(reference.pointer, - string.reference.pointer, class0.reference.pointer) + return _getParcelableArrayExtra1( + reference.pointer, + _id_getParcelableArrayExtra1 as jni.JMethodIDPtr, + string.reference.pointer, + class0.reference.pointer) .object(jni.JArrayType(T)); } - static final _getParcelableArrayListExtra = jniLookup< + static final _id_getParcelableArrayListExtra = _class.instanceMethodId( + r"getParcelableArrayListExtra", + r"(Ljava/lang/String;)Ljava/util/ArrayList;", + ); + + static final _getParcelableArrayListExtra = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Intent__getParcelableArrayListExtra") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.util.ArrayList getParcelableArrayListExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -9026,18 +12005,30 @@ class Intent extends jni.JObject { required jni.JObjType<$T> T, }) { return _getParcelableArrayListExtra( - reference.pointer, string.reference.pointer) + reference.pointer, + _id_getParcelableArrayListExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _getParcelableArrayListExtra1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "Intent__getParcelableArrayListExtra1") + static final _id_getParcelableArrayListExtra1 = _class.instanceMethodId( + r"getParcelableArrayListExtra", + r"(Ljava/lang/String;Ljava/lang/Class;)Ljava/util/ArrayList;", + ); + + static final _getParcelableArrayListExtra1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public java.util.ArrayList getParcelableArrayListExtra(java.lang.String string, java.lang.Class class) /// The returned object must be released after use, by calling the [release] method. @@ -9046,37 +12037,60 @@ class Intent extends jni.JObject { jni.JObject class0, { required jni.JObjType<$T> T, }) { - return _getParcelableArrayListExtra1(reference.pointer, - string.reference.pointer, class0.reference.pointer) + return _getParcelableArrayListExtra1( + reference.pointer, + _id_getParcelableArrayListExtra1 as jni.JMethodIDPtr, + string.reference.pointer, + class0.reference.pointer) .object(const jni.JObjectType()); } - static final _getSerializableExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getSerializableExtra") + static final _id_getSerializableExtra = _class.instanceMethodId( + r"getSerializableExtra", + r"(Ljava/lang/String;)Ljava/io/Serializable;", + ); + + static final _getSerializableExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.io.Serializable getSerializableExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getSerializableExtra( jni.JString string, ) { - return _getSerializableExtra(reference.pointer, string.reference.pointer) + return _getSerializableExtra( + reference.pointer, + _id_getSerializableExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _getSerializableExtra1 = jniLookup< + static final _id_getSerializableExtra1 = _class.instanceMethodId( + r"getSerializableExtra", + r"(Ljava/lang/String;Ljava/lang/Class;)Ljava/io/Serializable;", + ); + + static final _getSerializableExtra1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__getSerializableExtra1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public T getSerializableExtra(java.lang.String string, java.lang.Class class) /// The returned object must be released after use, by calling the [release] method. @@ -9085,18 +12099,29 @@ class Intent extends jni.JObject { jni.JObject class0, { required jni.JObjType<$T> T, }) { - return _getSerializableExtra1(reference.pointer, string.reference.pointer, + return _getSerializableExtra1( + reference.pointer, + _id_getSerializableExtra1 as jni.JMethodIDPtr, + string.reference.pointer, class0.reference.pointer) .object(T); } - static final _getIntegerArrayListExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getIntegerArrayListExtra") + static final _id_getIntegerArrayListExtra = _class.instanceMethodId( + r"getIntegerArrayListExtra", + r"(Ljava/lang/String;)Ljava/util/ArrayList;", + ); + + static final _getIntegerArrayListExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.util.ArrayList getIntegerArrayListExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -9104,35 +12129,55 @@ class Intent extends jni.JObject { jni.JString string, ) { return _getIntegerArrayListExtra( - reference.pointer, string.reference.pointer) + reference.pointer, + _id_getIntegerArrayListExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _getStringArrayListExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getStringArrayListExtra") + static final _id_getStringArrayListExtra = _class.instanceMethodId( + r"getStringArrayListExtra", + r"(Ljava/lang/String;)Ljava/util/ArrayList;", + ); + + static final _getStringArrayListExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.util.ArrayList getStringArrayListExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getStringArrayListExtra( jni.JString string, ) { - return _getStringArrayListExtra(reference.pointer, string.reference.pointer) + return _getStringArrayListExtra( + reference.pointer, + _id_getStringArrayListExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _getCharSequenceArrayListExtra = jniLookup< + static final _id_getCharSequenceArrayListExtra = _class.instanceMethodId( + r"getCharSequenceArrayListExtra", + r"(Ljava/lang/String;)Ljava/util/ArrayList;", + ); + + static final _getCharSequenceArrayListExtra = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Intent__getCharSequenceArrayListExtra") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.util.ArrayList getCharSequenceArrayListExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -9140,170 +12185,271 @@ class Intent extends jni.JObject { jni.JString string, ) { return _getCharSequenceArrayListExtra( - reference.pointer, string.reference.pointer) + reference.pointer, + _id_getCharSequenceArrayListExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JObjectType()); } - static final _getBooleanArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getBooleanArrayExtra") + static final _id_getBooleanArrayExtra = _class.instanceMethodId( + r"getBooleanArrayExtra", + r"(Ljava/lang/String;)[Z", + ); + + static final _getBooleanArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean[] getBooleanArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getBooleanArrayExtra( jni.JString string, ) { - return _getBooleanArrayExtra(reference.pointer, string.reference.pointer) + return _getBooleanArrayExtra( + reference.pointer, + _id_getBooleanArrayExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JArrayType(jni.jbooleanType())); } - static final _getByteArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getByteArrayExtra") + static final _id_getByteArrayExtra = _class.instanceMethodId( + r"getByteArrayExtra", + r"(Ljava/lang/String;)[B", + ); + + static final _getByteArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public byte[] getByteArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getByteArrayExtra( jni.JString string, ) { - return _getByteArrayExtra(reference.pointer, string.reference.pointer) + return _getByteArrayExtra(reference.pointer, + _id_getByteArrayExtra as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JArrayType(jni.jbyteType())); } - static final _getShortArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getShortArrayExtra") + static final _id_getShortArrayExtra = _class.instanceMethodId( + r"getShortArrayExtra", + r"(Ljava/lang/String;)[S", + ); + + static final _getShortArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public short[] getShortArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getShortArrayExtra( jni.JString string, ) { - return _getShortArrayExtra(reference.pointer, string.reference.pointer) + return _getShortArrayExtra( + reference.pointer, + _id_getShortArrayExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JArrayType(jni.jshortType())); } - static final _getCharArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getCharArrayExtra") + static final _id_getCharArrayExtra = _class.instanceMethodId( + r"getCharArrayExtra", + r"(Ljava/lang/String;)[C", + ); + + static final _getCharArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public char[] getCharArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getCharArrayExtra( jni.JString string, ) { - return _getCharArrayExtra(reference.pointer, string.reference.pointer) + return _getCharArrayExtra(reference.pointer, + _id_getCharArrayExtra as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JArrayType(jni.jcharType())); } - static final _getIntArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getIntArrayExtra") + static final _id_getIntArrayExtra = _class.instanceMethodId( + r"getIntArrayExtra", + r"(Ljava/lang/String;)[I", + ); + + static final _getIntArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public int[] getIntArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getIntArrayExtra( jni.JString string, ) { - return _getIntArrayExtra(reference.pointer, string.reference.pointer) + return _getIntArrayExtra(reference.pointer, + _id_getIntArrayExtra as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JArrayType(jni.jintType())); } - static final _getLongArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getLongArrayExtra") + static final _id_getLongArrayExtra = _class.instanceMethodId( + r"getLongArrayExtra", + r"(Ljava/lang/String;)[J", + ); + + static final _getLongArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public long[] getLongArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getLongArrayExtra( jni.JString string, ) { - return _getLongArrayExtra(reference.pointer, string.reference.pointer) + return _getLongArrayExtra(reference.pointer, + _id_getLongArrayExtra as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JArrayType(jni.jlongType())); } - static final _getFloatArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getFloatArrayExtra") + static final _id_getFloatArrayExtra = _class.instanceMethodId( + r"getFloatArrayExtra", + r"(Ljava/lang/String;)[F", + ); + + static final _getFloatArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public float[] getFloatArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getFloatArrayExtra( jni.JString string, ) { - return _getFloatArrayExtra(reference.pointer, string.reference.pointer) + return _getFloatArrayExtra( + reference.pointer, + _id_getFloatArrayExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JArrayType(jni.jfloatType())); } - static final _getDoubleArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getDoubleArrayExtra") + static final _id_getDoubleArrayExtra = _class.instanceMethodId( + r"getDoubleArrayExtra", + r"(Ljava/lang/String;)[D", + ); + + static final _getDoubleArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public double[] getDoubleArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getDoubleArrayExtra( jni.JString string, ) { - return _getDoubleArrayExtra(reference.pointer, string.reference.pointer) + return _getDoubleArrayExtra( + reference.pointer, + _id_getDoubleArrayExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JArrayType(jni.jdoubleType())); } - static final _getStringArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getStringArrayExtra") + static final _id_getStringArrayExtra = _class.instanceMethodId( + r"getStringArrayExtra", + r"(Ljava/lang/String;)[Ljava/lang/String;", + ); + + static final _getStringArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.lang.String[] getStringArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JArray getStringArrayExtra( jni.JString string, ) { - return _getStringArrayExtra(reference.pointer, string.reference.pointer) + return _getStringArrayExtra( + reference.pointer, + _id_getStringArrayExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JArrayType(jni.JStringType())); } - static final _getCharSequenceArrayExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getCharSequenceArrayExtra") + static final _id_getCharSequenceArrayExtra = _class.instanceMethodId( + r"getCharSequenceArrayExtra", + r"(Ljava/lang/String;)[Ljava/lang/CharSequence;", + ); + + static final _getCharSequenceArrayExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.lang.CharSequence[] getCharSequenceArrayExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -9311,112 +12457,202 @@ class Intent extends jni.JObject { jni.JString string, ) { return _getCharSequenceArrayExtra( - reference.pointer, string.reference.pointer) + reference.pointer, + _id_getCharSequenceArrayExtra as jni.JMethodIDPtr, + string.reference.pointer) .object(const jni.JArrayType(jni.JObjectType())); } - static final _getBundleExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__getBundleExtra") + static final _id_getBundleExtra = _class.instanceMethodId( + r"getBundleExtra", + r"(Ljava/lang/String;)Landroid/os/Bundle;", + ); + + static final _getBundleExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.os.Bundle getBundleExtra(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getBundleExtra( jni.JString string, ) { - return _getBundleExtra(reference.pointer, string.reference.pointer) + return _getBundleExtra(reference.pointer, + _id_getBundleExtra as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JObjectType()); } - static final _getExtras = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getExtras") - .asFunction)>(); + static final _id_getExtras = _class.instanceMethodId( + r"getExtras", + r"()Landroid/os/Bundle;", + ); + + static final _getExtras = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.os.Bundle getExtras() /// The returned object must be released after use, by calling the [release] method. jni.JObject getExtras() { - return _getExtras(reference.pointer).object(const jni.JObjectType()); + return _getExtras(reference.pointer, _id_getExtras as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getFlags = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getFlags") - .asFunction)>(); + static final _id_getFlags = _class.instanceMethodId( + r"getFlags", + r"()I", + ); + + static final _getFlags = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int getFlags() int getFlags() { - return _getFlags(reference.pointer).integer; + return _getFlags(reference.pointer, _id_getFlags as jni.JMethodIDPtr) + .integer; } - static final _getPackage = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getPackage") - .asFunction)>(); + static final _id_getPackage = _class.instanceMethodId( + r"getPackage", + r"()Ljava/lang/String;", + ); + + static final _getPackage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getPackage() /// The returned object must be released after use, by calling the [release] method. jni.JString getPackage() { - return _getPackage(reference.pointer).object(const jni.JStringType()); + return _getPackage(reference.pointer, _id_getPackage as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _getComponent = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getComponent") - .asFunction)>(); + static final _id_getComponent = _class.instanceMethodId( + r"getComponent", + r"()Landroid/content/ComponentName;", + ); + + static final _getComponent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.ComponentName getComponent() /// The returned object must be released after use, by calling the [release] method. jni.JObject getComponent() { - return _getComponent(reference.pointer).object(const jni.JObjectType()); + return _getComponent( + reference.pointer, _id_getComponent as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getSourceBounds = jniLookup< - ffi - .NativeFunction)>>( - "Intent__getSourceBounds") - .asFunction)>(); + static final _id_getSourceBounds = _class.instanceMethodId( + r"getSourceBounds", + r"()Landroid/graphics/Rect;", + ); + + static final _getSourceBounds = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.graphics.Rect getSourceBounds() /// The returned object must be released after use, by calling the [release] method. jni.JObject getSourceBounds() { - return _getSourceBounds(reference.pointer).object(const jni.JObjectType()); + return _getSourceBounds( + reference.pointer, _id_getSourceBounds as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _resolveActivity = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__resolveActivity") + static final _id_resolveActivity = _class.instanceMethodId( + r"resolveActivity", + r"(Landroid/content/pm/PackageManager;)Landroid/content/ComponentName;", + ); + + static final _resolveActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.ComponentName resolveActivity(android.content.pm.PackageManager packageManager) /// The returned object must be released after use, by calling the [release] method. jni.JObject resolveActivity( jni.JObject packageManager, ) { - return _resolveActivity(reference.pointer, packageManager.reference.pointer) + return _resolveActivity( + reference.pointer, + _id_resolveActivity as jni.JMethodIDPtr, + packageManager.reference.pointer) .object(const jni.JObjectType()); } - static final _resolveActivityInfo = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Intent__resolveActivityInfo") + static final _id_resolveActivityInfo = _class.instanceMethodId( + r"resolveActivityInfo", + r"(Landroid/content/pm/PackageManager;I)Landroid/content/pm/ActivityInfo;", + ); + + static final _resolveActivityInfo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.content.pm.ActivityInfo resolveActivityInfo(android.content.pm.PackageManager packageManager, int i) /// The returned object must be released after use, by calling the [release] method. @@ -9425,104 +12661,163 @@ class Intent extends jni.JObject { int i, ) { return _resolveActivityInfo( - reference.pointer, packageManager.reference.pointer, i) + reference.pointer, + _id_resolveActivityInfo as jni.JMethodIDPtr, + packageManager.reference.pointer, + i) .object(const jni.JObjectType()); } - static final _setAction = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setAction") + static final _id_setAction = _class.instanceMethodId( + r"setAction", + r"(Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setAction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent setAction(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. Intent setAction( jni.JString string, ) { - return _setAction(reference.pointer, string.reference.pointer) + return _setAction(reference.pointer, _id_setAction as jni.JMethodIDPtr, + string.reference.pointer) .object(const $IntentType()); } - static final _setData = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setData") + static final _id_setData = _class.instanceMethodId( + r"setData", + r"(Landroid/net/Uri;)Landroid/content/Intent;", + ); + + static final _setData = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent setData(android.net.Uri uri) /// The returned object must be released after use, by calling the [release] method. Intent setData( jni.JObject uri, ) { - return _setData(reference.pointer, uri.reference.pointer) + return _setData(reference.pointer, _id_setData as jni.JMethodIDPtr, + uri.reference.pointer) .object(const $IntentType()); } - static final _setDataAndNormalize = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setDataAndNormalize") + static final _id_setDataAndNormalize = _class.instanceMethodId( + r"setDataAndNormalize", + r"(Landroid/net/Uri;)Landroid/content/Intent;", + ); + + static final _setDataAndNormalize = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent setDataAndNormalize(android.net.Uri uri) /// The returned object must be released after use, by calling the [release] method. Intent setDataAndNormalize( jni.JObject uri, ) { - return _setDataAndNormalize(reference.pointer, uri.reference.pointer) + return _setDataAndNormalize(reference.pointer, + _id_setDataAndNormalize as jni.JMethodIDPtr, uri.reference.pointer) .object(const $IntentType()); } - static final _setType = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setType") + static final _id_setType = _class.instanceMethodId( + r"setType", + r"(Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setType = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent setType(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. Intent setType( jni.JString string, ) { - return _setType(reference.pointer, string.reference.pointer) + return _setType(reference.pointer, _id_setType as jni.JMethodIDPtr, + string.reference.pointer) .object(const $IntentType()); } - static final _setTypeAndNormalize = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setTypeAndNormalize") + static final _id_setTypeAndNormalize = _class.instanceMethodId( + r"setTypeAndNormalize", + r"(Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setTypeAndNormalize = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent setTypeAndNormalize(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. Intent setTypeAndNormalize( jni.JString string, ) { - return _setTypeAndNormalize(reference.pointer, string.reference.pointer) + return _setTypeAndNormalize( + reference.pointer, + _id_setTypeAndNormalize as jni.JMethodIDPtr, + string.reference.pointer) .object(const $IntentType()); } - static final _setDataAndType = jniLookup< + static final _id_setDataAndType = _class.instanceMethodId( + r"setDataAndType", + r"(Landroid/net/Uri;Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setDataAndType = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__setDataAndType") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent setDataAndType(android.net.Uri uri, java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -9531,19 +12826,31 @@ class Intent extends jni.JObject { jni.JString string, ) { return _setDataAndType( - reference.pointer, uri.reference.pointer, string.reference.pointer) + reference.pointer, + _id_setDataAndType as jni.JMethodIDPtr, + uri.reference.pointer, + string.reference.pointer) .object(const $IntentType()); } - static final _setDataAndTypeAndNormalize = jniLookup< + static final _id_setDataAndTypeAndNormalize = _class.instanceMethodId( + r"setDataAndTypeAndNormalize", + r"(Landroid/net/Uri;Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setDataAndTypeAndNormalize = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__setDataAndTypeAndNormalize") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent setDataAndTypeAndNormalize(android.net.Uri uri, java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -9552,96 +12859,155 @@ class Intent extends jni.JObject { jni.JString string, ) { return _setDataAndTypeAndNormalize( - reference.pointer, uri.reference.pointer, string.reference.pointer) + reference.pointer, + _id_setDataAndTypeAndNormalize as jni.JMethodIDPtr, + uri.reference.pointer, + string.reference.pointer) .object(const $IntentType()); } - static final _setIdentifier = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setIdentifier") + static final _id_setIdentifier = _class.instanceMethodId( + r"setIdentifier", + r"(Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setIdentifier = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent setIdentifier(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. Intent setIdentifier( jni.JString string, ) { - return _setIdentifier(reference.pointer, string.reference.pointer) + return _setIdentifier(reference.pointer, + _id_setIdentifier as jni.JMethodIDPtr, string.reference.pointer) .object(const $IntentType()); } - static final _addCategory = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__addCategory") + static final _id_addCategory = _class.instanceMethodId( + r"addCategory", + r"(Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _addCategory = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent addCategory(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. Intent addCategory( jni.JString string, ) { - return _addCategory(reference.pointer, string.reference.pointer) + return _addCategory(reference.pointer, _id_addCategory as jni.JMethodIDPtr, + string.reference.pointer) .object(const $IntentType()); } - static final _removeCategory = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__removeCategory") + static final _id_removeCategory = _class.instanceMethodId( + r"removeCategory", + r"(Ljava/lang/String;)V", + ); + + static final _removeCategory = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void removeCategory(java.lang.String string) void removeCategory( jni.JString string, ) { - _removeCategory(reference.pointer, string.reference.pointer).check(); + _removeCategory(reference.pointer, _id_removeCategory as jni.JMethodIDPtr, + string.reference.pointer) + .check(); } - static final _setSelector = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setSelector") + static final _id_setSelector = _class.instanceMethodId( + r"setSelector", + r"(Landroid/content/Intent;)V", + ); + + static final _setSelector = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setSelector(android.content.Intent intent) void setSelector( Intent intent, ) { - _setSelector(reference.pointer, intent.reference.pointer).check(); + _setSelector(reference.pointer, _id_setSelector as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); } - static final _setClipData = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setClipData") + static final _id_setClipData = _class.instanceMethodId( + r"setClipData", + r"(Landroid/content/ClipData;)V", + ); + + static final _setClipData = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setClipData(android.content.ClipData clipData) void setClipData( jni.JObject clipData, ) { - _setClipData(reference.pointer, clipData.reference.pointer).check(); + _setClipData(reference.pointer, _id_setClipData as jni.JMethodIDPtr, + clipData.reference.pointer) + .check(); } - static final _putExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Uint8)>>("Intent__putExtra") + static final _id_putExtra = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;Z)Landroid/content/Intent;", + ); + + static final _putExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.content.Intent putExtra(java.lang.String string, boolean z) /// The returned object must be released after use, by calling the [release] method. @@ -9649,17 +13015,26 @@ class Intent extends jni.JObject { jni.JString string, bool z, ) { - return _putExtra(reference.pointer, string.reference.pointer, z ? 1 : 0) + return _putExtra(reference.pointer, _id_putExtra as jni.JMethodIDPtr, + string.reference.pointer, z ? 1 : 0) .object(const $IntentType()); } - static final _putExtra1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int8)>>("Intent__putExtra1") + static final _id_putExtra1 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;B)Landroid/content/Intent;", + ); + + static final _putExtra1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.content.Intent putExtra(java.lang.String string, byte b) /// The returned object must be released after use, by calling the [release] method. @@ -9667,17 +13042,26 @@ class Intent extends jni.JObject { jni.JString string, int b, ) { - return _putExtra1(reference.pointer, string.reference.pointer, b) + return _putExtra1(reference.pointer, _id_putExtra1 as jni.JMethodIDPtr, + string.reference.pointer, b) .object(const $IntentType()); } - static final _putExtra2 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Uint16)>>("Intent__putExtra2") + static final _id_putExtra2 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;C)Landroid/content/Intent;", + ); + + static final _putExtra2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.content.Intent putExtra(java.lang.String string, char c) /// The returned object must be released after use, by calling the [release] method. @@ -9685,17 +13069,26 @@ class Intent extends jni.JObject { jni.JString string, int c, ) { - return _putExtra2(reference.pointer, string.reference.pointer, c) + return _putExtra2(reference.pointer, _id_putExtra2 as jni.JMethodIDPtr, + string.reference.pointer, c) .object(const $IntentType()); } - static final _putExtra3 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int16)>>("Intent__putExtra3") + static final _id_putExtra3 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;S)Landroid/content/Intent;", + ); + + static final _putExtra3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.content.Intent putExtra(java.lang.String string, short s) /// The returned object must be released after use, by calling the [release] method. @@ -9703,17 +13096,26 @@ class Intent extends jni.JObject { jni.JString string, int s, ) { - return _putExtra3(reference.pointer, string.reference.pointer, s) + return _putExtra3(reference.pointer, _id_putExtra3 as jni.JMethodIDPtr, + string.reference.pointer, s) .object(const $IntentType()); } - static final _putExtra4 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int32)>>("Intent__putExtra4") + static final _id_putExtra4 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;I)Landroid/content/Intent;", + ); + + static final _putExtra4 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.content.Intent putExtra(java.lang.String string, int i) /// The returned object must be released after use, by calling the [release] method. @@ -9721,17 +13123,26 @@ class Intent extends jni.JObject { jni.JString string, int i, ) { - return _putExtra4(reference.pointer, string.reference.pointer, i) + return _putExtra4(reference.pointer, _id_putExtra4 as jni.JMethodIDPtr, + string.reference.pointer, i) .object(const $IntentType()); } - static final _putExtra5 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int64)>>("Intent__putExtra5") + static final _id_putExtra5 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;J)Landroid/content/Intent;", + ); + + static final _putExtra5 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.content.Intent putExtra(java.lang.String string, long j) /// The returned object must be released after use, by calling the [release] method. @@ -9739,17 +13150,26 @@ class Intent extends jni.JObject { jni.JString string, int j, ) { - return _putExtra5(reference.pointer, string.reference.pointer, j) + return _putExtra5(reference.pointer, _id_putExtra5 as jni.JMethodIDPtr, + string.reference.pointer, j) .object(const $IntentType()); } - static final _putExtra6 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Float)>>("Intent__putExtra6") + static final _id_putExtra6 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;F)Landroid/content/Intent;", + ); + + static final _putExtra6 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Double)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, double)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, double)>(); /// from: public android.content.Intent putExtra(java.lang.String string, float f) /// The returned object must be released after use, by calling the [release] method. @@ -9757,17 +13177,26 @@ class Intent extends jni.JObject { jni.JString string, double f, ) { - return _putExtra6(reference.pointer, string.reference.pointer, f) + return _putExtra6(reference.pointer, _id_putExtra6 as jni.JMethodIDPtr, + string.reference.pointer, f) .object(const $IntentType()); } - static final _putExtra7 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Double)>>("Intent__putExtra7") + static final _id_putExtra7 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;D)Landroid/content/Intent;", + ); + + static final _putExtra7 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Double)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, double)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, double)>(); /// from: public android.content.Intent putExtra(java.lang.String string, double d) /// The returned object must be released after use, by calling the [release] method. @@ -9775,19 +13204,29 @@ class Intent extends jni.JObject { jni.JString string, double d, ) { - return _putExtra7(reference.pointer, string.reference.pointer, d) + return _putExtra7(reference.pointer, _id_putExtra7 as jni.JMethodIDPtr, + string.reference.pointer, d) .object(const $IntentType()); } - static final _putExtra8 = jniLookup< + static final _id_putExtra8 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _putExtra8 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra8") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, java.lang.String string1) /// The returned object must be released after use, by calling the [release] method. @@ -9795,20 +13234,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JString string1, ) { - return _putExtra8(reference.pointer, string.reference.pointer, - string1.reference.pointer) + return _putExtra8(reference.pointer, _id_putExtra8 as jni.JMethodIDPtr, + string.reference.pointer, string1.reference.pointer) .object(const $IntentType()); } - static final _putExtra9 = jniLookup< + static final _id_putExtra9 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;Ljava/lang/CharSequence;)Landroid/content/Intent;", + ); + + static final _putExtra9 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra9") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, java.lang.CharSequence charSequence) /// The returned object must be released after use, by calling the [release] method. @@ -9816,20 +13264,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject charSequence, ) { - return _putExtra9(reference.pointer, string.reference.pointer, - charSequence.reference.pointer) + return _putExtra9(reference.pointer, _id_putExtra9 as jni.JMethodIDPtr, + string.reference.pointer, charSequence.reference.pointer) .object(const $IntentType()); } - static final _putExtra10 = jniLookup< + static final _id_putExtra10 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;Landroid/os/Parcelable;)Landroid/content/Intent;", + ); + + static final _putExtra10 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra10") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, android.os.Parcelable parcelable) /// The returned object must be released after use, by calling the [release] method. @@ -9837,20 +13294,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject parcelable, ) { - return _putExtra10(reference.pointer, string.reference.pointer, - parcelable.reference.pointer) + return _putExtra10(reference.pointer, _id_putExtra10 as jni.JMethodIDPtr, + string.reference.pointer, parcelable.reference.pointer) .object(const $IntentType()); } - static final _putExtra11 = jniLookup< + static final _id_putExtra11 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[Landroid/os/Parcelable;)Landroid/content/Intent;", + ); + + static final _putExtra11 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra11") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, android.os.Parcelable[] parcelables) /// The returned object must be released after use, by calling the [release] method. @@ -9858,19 +13324,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray parcelables, ) { - return _putExtra11(reference.pointer, string.reference.pointer, - parcelables.reference.pointer) + return _putExtra11(reference.pointer, _id_putExtra11 as jni.JMethodIDPtr, + string.reference.pointer, parcelables.reference.pointer) .object(const $IntentType()); } - static final _putParcelableArrayListExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "Intent__putParcelableArrayListExtra") + static final _id_putParcelableArrayListExtra = _class.instanceMethodId( + r"putParcelableArrayListExtra", + r"(Ljava/lang/String;Ljava/util/ArrayList;)Landroid/content/Intent;", + ); + + static final _putParcelableArrayListExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putParcelableArrayListExtra(java.lang.String string, java.util.ArrayList arrayList) /// The returned object must be released after use, by calling the [release] method. @@ -9878,20 +13354,32 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject arrayList, ) { - return _putParcelableArrayListExtra(reference.pointer, - string.reference.pointer, arrayList.reference.pointer) + return _putParcelableArrayListExtra( + reference.pointer, + _id_putParcelableArrayListExtra as jni.JMethodIDPtr, + string.reference.pointer, + arrayList.reference.pointer) .object(const $IntentType()); } - static final _putIntegerArrayListExtra = jniLookup< + static final _id_putIntegerArrayListExtra = _class.instanceMethodId( + r"putIntegerArrayListExtra", + r"(Ljava/lang/String;Ljava/util/ArrayList;)Landroid/content/Intent;", + ); + + static final _putIntegerArrayListExtra = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putIntegerArrayListExtra") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putIntegerArrayListExtra(java.lang.String string, java.util.ArrayList arrayList) /// The returned object must be released after use, by calling the [release] method. @@ -9899,20 +13387,32 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject arrayList, ) { - return _putIntegerArrayListExtra(reference.pointer, - string.reference.pointer, arrayList.reference.pointer) + return _putIntegerArrayListExtra( + reference.pointer, + _id_putIntegerArrayListExtra as jni.JMethodIDPtr, + string.reference.pointer, + arrayList.reference.pointer) .object(const $IntentType()); } - static final _putStringArrayListExtra = jniLookup< + static final _id_putStringArrayListExtra = _class.instanceMethodId( + r"putStringArrayListExtra", + r"(Ljava/lang/String;Ljava/util/ArrayList;)Landroid/content/Intent;", + ); + + static final _putStringArrayListExtra = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putStringArrayListExtra") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putStringArrayListExtra(java.lang.String string, java.util.ArrayList arrayList) /// The returned object must be released after use, by calling the [release] method. @@ -9920,19 +13420,32 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject arrayList, ) { - return _putStringArrayListExtra(reference.pointer, string.reference.pointer, + return _putStringArrayListExtra( + reference.pointer, + _id_putStringArrayListExtra as jni.JMethodIDPtr, + string.reference.pointer, arrayList.reference.pointer) .object(const $IntentType()); } - static final _putCharSequenceArrayListExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "Intent__putCharSequenceArrayListExtra") + static final _id_putCharSequenceArrayListExtra = _class.instanceMethodId( + r"putCharSequenceArrayListExtra", + r"(Ljava/lang/String;Ljava/util/ArrayList;)Landroid/content/Intent;", + ); + + static final _putCharSequenceArrayListExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putCharSequenceArrayListExtra(java.lang.String string, java.util.ArrayList arrayList) /// The returned object must be released after use, by calling the [release] method. @@ -9940,20 +13453,32 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject arrayList, ) { - return _putCharSequenceArrayListExtra(reference.pointer, - string.reference.pointer, arrayList.reference.pointer) + return _putCharSequenceArrayListExtra( + reference.pointer, + _id_putCharSequenceArrayListExtra as jni.JMethodIDPtr, + string.reference.pointer, + arrayList.reference.pointer) .object(const $IntentType()); } - static final _putExtra12 = jniLookup< + static final _id_putExtra12 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;Ljava/io/Serializable;)Landroid/content/Intent;", + ); + + static final _putExtra12 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra12") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, java.io.Serializable serializable) /// The returned object must be released after use, by calling the [release] method. @@ -9961,20 +13486,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject serializable, ) { - return _putExtra12(reference.pointer, string.reference.pointer, - serializable.reference.pointer) + return _putExtra12(reference.pointer, _id_putExtra12 as jni.JMethodIDPtr, + string.reference.pointer, serializable.reference.pointer) .object(const $IntentType()); } - static final _putExtra13 = jniLookup< + static final _id_putExtra13 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[Z)Landroid/content/Intent;", + ); + + static final _putExtra13 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra13") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, boolean[] zs) /// The returned object must be released after use, by calling the [release] method. @@ -9982,20 +13516,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray zs, ) { - return _putExtra13( - reference.pointer, string.reference.pointer, zs.reference.pointer) + return _putExtra13(reference.pointer, _id_putExtra13 as jni.JMethodIDPtr, + string.reference.pointer, zs.reference.pointer) .object(const $IntentType()); } - static final _putExtra14 = jniLookup< + static final _id_putExtra14 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[B)Landroid/content/Intent;", + ); + + static final _putExtra14 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra14") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, byte[] bs) /// The returned object must be released after use, by calling the [release] method. @@ -10003,20 +13546,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray bs, ) { - return _putExtra14( - reference.pointer, string.reference.pointer, bs.reference.pointer) + return _putExtra14(reference.pointer, _id_putExtra14 as jni.JMethodIDPtr, + string.reference.pointer, bs.reference.pointer) .object(const $IntentType()); } - static final _putExtra15 = jniLookup< + static final _id_putExtra15 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[S)Landroid/content/Intent;", + ); + + static final _putExtra15 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra15") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, short[] ss) /// The returned object must be released after use, by calling the [release] method. @@ -10024,20 +13576,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray ss, ) { - return _putExtra15( - reference.pointer, string.reference.pointer, ss.reference.pointer) + return _putExtra15(reference.pointer, _id_putExtra15 as jni.JMethodIDPtr, + string.reference.pointer, ss.reference.pointer) .object(const $IntentType()); } - static final _putExtra16 = jniLookup< + static final _id_putExtra16 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[C)Landroid/content/Intent;", + ); + + static final _putExtra16 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra16") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, char[] cs) /// The returned object must be released after use, by calling the [release] method. @@ -10045,20 +13606,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray cs, ) { - return _putExtra16( - reference.pointer, string.reference.pointer, cs.reference.pointer) + return _putExtra16(reference.pointer, _id_putExtra16 as jni.JMethodIDPtr, + string.reference.pointer, cs.reference.pointer) .object(const $IntentType()); } - static final _putExtra17 = jniLookup< + static final _id_putExtra17 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[I)Landroid/content/Intent;", + ); + + static final _putExtra17 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra17") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, int[] is) /// The returned object must be released after use, by calling the [release] method. @@ -10066,20 +13636,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray is0, ) { - return _putExtra17( - reference.pointer, string.reference.pointer, is0.reference.pointer) + return _putExtra17(reference.pointer, _id_putExtra17 as jni.JMethodIDPtr, + string.reference.pointer, is0.reference.pointer) .object(const $IntentType()); } - static final _putExtra18 = jniLookup< + static final _id_putExtra18 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[J)Landroid/content/Intent;", + ); + + static final _putExtra18 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra18") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, long[] js) /// The returned object must be released after use, by calling the [release] method. @@ -10087,20 +13666,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray js, ) { - return _putExtra18( - reference.pointer, string.reference.pointer, js.reference.pointer) + return _putExtra18(reference.pointer, _id_putExtra18 as jni.JMethodIDPtr, + string.reference.pointer, js.reference.pointer) .object(const $IntentType()); } - static final _putExtra19 = jniLookup< + static final _id_putExtra19 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[F)Landroid/content/Intent;", + ); + + static final _putExtra19 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra19") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, float[] fs) /// The returned object must be released after use, by calling the [release] method. @@ -10108,20 +13696,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray fs, ) { - return _putExtra19( - reference.pointer, string.reference.pointer, fs.reference.pointer) + return _putExtra19(reference.pointer, _id_putExtra19 as jni.JMethodIDPtr, + string.reference.pointer, fs.reference.pointer) .object(const $IntentType()); } - static final _putExtra20 = jniLookup< + static final _id_putExtra20 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[D)Landroid/content/Intent;", + ); + + static final _putExtra20 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra20") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, double[] ds) /// The returned object must be released after use, by calling the [release] method. @@ -10129,20 +13726,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray ds, ) { - return _putExtra20( - reference.pointer, string.reference.pointer, ds.reference.pointer) + return _putExtra20(reference.pointer, _id_putExtra20 as jni.JMethodIDPtr, + string.reference.pointer, ds.reference.pointer) .object(const $IntentType()); } - static final _putExtra21 = jniLookup< + static final _id_putExtra21 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _putExtra21 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra21") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, java.lang.String[] strings) /// The returned object must be released after use, by calling the [release] method. @@ -10150,20 +13756,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray strings, ) { - return _putExtra21(reference.pointer, string.reference.pointer, - strings.reference.pointer) + return _putExtra21(reference.pointer, _id_putExtra21 as jni.JMethodIDPtr, + string.reference.pointer, strings.reference.pointer) .object(const $IntentType()); } - static final _putExtra22 = jniLookup< + static final _id_putExtra22 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;[Ljava/lang/CharSequence;)Landroid/content/Intent;", + ); + + static final _putExtra22 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra22") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, java.lang.CharSequence[] charSequences) /// The returned object must be released after use, by calling the [release] method. @@ -10171,20 +13786,29 @@ class Intent extends jni.JObject { jni.JString string, jni.JArray charSequences, ) { - return _putExtra22(reference.pointer, string.reference.pointer, - charSequences.reference.pointer) + return _putExtra22(reference.pointer, _id_putExtra22 as jni.JMethodIDPtr, + string.reference.pointer, charSequences.reference.pointer) .object(const $IntentType()); } - static final _putExtra23 = jniLookup< + static final _id_putExtra23 = _class.instanceMethodId( + r"putExtra", + r"(Ljava/lang/String;Landroid/os/Bundle;)Landroid/content/Intent;", + ); + + static final _putExtra23 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__putExtra23") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent putExtra(java.lang.String string, android.os.Bundle bundle) /// The returned object must be released after use, by calling the [release] method. @@ -10192,178 +13816,279 @@ class Intent extends jni.JObject { jni.JString string, jni.JObject bundle, ) { - return _putExtra23(reference.pointer, string.reference.pointer, - bundle.reference.pointer) + return _putExtra23(reference.pointer, _id_putExtra23 as jni.JMethodIDPtr, + string.reference.pointer, bundle.reference.pointer) .object(const $IntentType()); } - static final _putExtras = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__putExtras") + static final _id_putExtras = _class.instanceMethodId( + r"putExtras", + r"(Landroid/content/Intent;)Landroid/content/Intent;", + ); + + static final _putExtras = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent putExtras(android.content.Intent intent) /// The returned object must be released after use, by calling the [release] method. Intent putExtras( Intent intent, ) { - return _putExtras(reference.pointer, intent.reference.pointer) + return _putExtras(reference.pointer, _id_putExtras as jni.JMethodIDPtr, + intent.reference.pointer) .object(const $IntentType()); } - static final _putExtras1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__putExtras1") + static final _id_putExtras1 = _class.instanceMethodId( + r"putExtras", + r"(Landroid/os/Bundle;)Landroid/content/Intent;", + ); + + static final _putExtras1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent putExtras(android.os.Bundle bundle) /// The returned object must be released after use, by calling the [release] method. Intent putExtras1( jni.JObject bundle, ) { - return _putExtras1(reference.pointer, bundle.reference.pointer) + return _putExtras1(reference.pointer, _id_putExtras1 as jni.JMethodIDPtr, + bundle.reference.pointer) .object(const $IntentType()); } - static final _replaceExtras = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__replaceExtras") + static final _id_replaceExtras = _class.instanceMethodId( + r"replaceExtras", + r"(Landroid/content/Intent;)Landroid/content/Intent;", + ); + + static final _replaceExtras = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent replaceExtras(android.content.Intent intent) /// The returned object must be released after use, by calling the [release] method. Intent replaceExtras( Intent intent, ) { - return _replaceExtras(reference.pointer, intent.reference.pointer) + return _replaceExtras(reference.pointer, + _id_replaceExtras as jni.JMethodIDPtr, intent.reference.pointer) .object(const $IntentType()); } - static final _replaceExtras1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__replaceExtras1") + static final _id_replaceExtras1 = _class.instanceMethodId( + r"replaceExtras", + r"(Landroid/os/Bundle;)Landroid/content/Intent;", + ); + + static final _replaceExtras1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent replaceExtras(android.os.Bundle bundle) /// The returned object must be released after use, by calling the [release] method. Intent replaceExtras1( jni.JObject bundle, ) { - return _replaceExtras1(reference.pointer, bundle.reference.pointer) + return _replaceExtras1(reference.pointer, + _id_replaceExtras1 as jni.JMethodIDPtr, bundle.reference.pointer) .object(const $IntentType()); } - static final _removeExtra = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__removeExtra") + static final _id_removeExtra = _class.instanceMethodId( + r"removeExtra", + r"(Ljava/lang/String;)V", + ); + + static final _removeExtra = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void removeExtra(java.lang.String string) void removeExtra( jni.JString string, ) { - _removeExtra(reference.pointer, string.reference.pointer).check(); + _removeExtra(reference.pointer, _id_removeExtra as jni.JMethodIDPtr, + string.reference.pointer) + .check(); } - static final _setFlags = jniLookup< + static final _id_setFlags = _class.instanceMethodId( + r"setFlags", + r"(I)Landroid/content/Intent;", + ); + + static final _setFlags = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Intent__setFlags") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public android.content.Intent setFlags(int i) /// The returned object must be released after use, by calling the [release] method. Intent setFlags( int i, ) { - return _setFlags(reference.pointer, i).object(const $IntentType()); + return _setFlags(reference.pointer, _id_setFlags as jni.JMethodIDPtr, i) + .object(const $IntentType()); } - static final _addFlags = jniLookup< + static final _id_addFlags = _class.instanceMethodId( + r"addFlags", + r"(I)Landroid/content/Intent;", + ); + + static final _addFlags = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Intent__addFlags") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public android.content.Intent addFlags(int i) /// The returned object must be released after use, by calling the [release] method. Intent addFlags( int i, ) { - return _addFlags(reference.pointer, i).object(const $IntentType()); + return _addFlags(reference.pointer, _id_addFlags as jni.JMethodIDPtr, i) + .object(const $IntentType()); } - static final _removeFlags = jniLookup< + static final _id_removeFlags = _class.instanceMethodId( + r"removeFlags", + r"(I)V", + ); + + static final _removeFlags = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Intent__removeFlags") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void removeFlags(int i) void removeFlags( int i, ) { - _removeFlags(reference.pointer, i).check(); + _removeFlags(reference.pointer, _id_removeFlags as jni.JMethodIDPtr, i) + .check(); } - static final _setPackage = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setPackage") + static final _id_setPackage = _class.instanceMethodId( + r"setPackage", + r"(Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setPackage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent setPackage(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. Intent setPackage( jni.JString string, ) { - return _setPackage(reference.pointer, string.reference.pointer) + return _setPackage(reference.pointer, _id_setPackage as jni.JMethodIDPtr, + string.reference.pointer) .object(const $IntentType()); } - static final _setComponent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setComponent") + static final _id_setComponent = _class.instanceMethodId( + r"setComponent", + r"(Landroid/content/ComponentName;)Landroid/content/Intent;", + ); + + static final _setComponent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.content.Intent setComponent(android.content.ComponentName componentName) /// The returned object must be released after use, by calling the [release] method. Intent setComponent( jni.JObject componentName, ) { - return _setComponent(reference.pointer, componentName.reference.pointer) + return _setComponent( + reference.pointer, + _id_setComponent as jni.JMethodIDPtr, + componentName.reference.pointer) .object(const $IntentType()); } - static final _setClassName = jniLookup< + static final _id_setClassName = _class.instanceMethodId( + r"setClassName", + r"(Landroid/content/Context;Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setClassName = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__setClassName") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent setClassName(android.content.Context context, java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -10371,20 +14096,32 @@ class Intent extends jni.JObject { Context context, jni.JString string, ) { - return _setClassName(reference.pointer, context.reference.pointer, + return _setClassName( + reference.pointer, + _id_setClassName as jni.JMethodIDPtr, + context.reference.pointer, string.reference.pointer) .object(const $IntentType()); } - static final _setClassName1 = jniLookup< + static final _id_setClassName1 = _class.instanceMethodId( + r"setClassName", + r"(Ljava/lang/String;Ljava/lang/String;)Landroid/content/Intent;", + ); + + static final _setClassName1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__setClassName1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent setClassName(java.lang.String string, java.lang.String string1) /// The returned object must be released after use, by calling the [release] method. @@ -10392,20 +14129,32 @@ class Intent extends jni.JObject { jni.JString string, jni.JString string1, ) { - return _setClassName1(reference.pointer, string.reference.pointer, + return _setClassName1( + reference.pointer, + _id_setClassName1 as jni.JMethodIDPtr, + string.reference.pointer, string1.reference.pointer) .object(const $IntentType()); } - static final _setClass = jniLookup< + static final _id_setClass = _class.instanceMethodId( + r"setClass", + r"(Landroid/content/Context;Ljava/lang/Class;)Landroid/content/Intent;", + ); + + static final _setClass = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__setClass") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public android.content.Intent setClass(android.content.Context context, java.lang.Class class) /// The returned object must be released after use, by calling the [release] method. @@ -10413,155 +14162,278 @@ class Intent extends jni.JObject { Context context, jni.JObject class0, ) { - return _setClass(reference.pointer, context.reference.pointer, - class0.reference.pointer) + return _setClass(reference.pointer, _id_setClass as jni.JMethodIDPtr, + context.reference.pointer, class0.reference.pointer) .object(const $IntentType()); } - static final _setSourceBounds = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__setSourceBounds") + static final _id_setSourceBounds = _class.instanceMethodId( + r"setSourceBounds", + r"(Landroid/graphics/Rect;)V", + ); + + static final _setSourceBounds = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setSourceBounds(android.graphics.Rect rect) void setSourceBounds( jni.JObject rect, ) { - _setSourceBounds(reference.pointer, rect.reference.pointer).check(); + _setSourceBounds(reference.pointer, _id_setSourceBounds as jni.JMethodIDPtr, + rect.reference.pointer) + .check(); } - static final _fillIn = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int32)>>("Intent__fillIn") + static final _id_fillIn = _class.instanceMethodId( + r"fillIn", + r"(Landroid/content/Intent;I)I", + ); + + static final _fillIn = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public int fillIn(android.content.Intent intent, int i) int fillIn( Intent intent, int i, ) { - return _fillIn(reference.pointer, intent.reference.pointer, i).integer; + return _fillIn(reference.pointer, _id_fillIn as jni.JMethodIDPtr, + intent.reference.pointer, i) + .integer; } - static final _filterEquals = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__filterEquals") + static final _id_filterEquals = _class.instanceMethodId( + r"filterEquals", + r"(Landroid/content/Intent;)Z", + ); + + static final _filterEquals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean filterEquals(android.content.Intent intent) bool filterEquals( Intent intent, ) { - return _filterEquals(reference.pointer, intent.reference.pointer).boolean; + return _filterEquals(reference.pointer, + _id_filterEquals as jni.JMethodIDPtr, intent.reference.pointer) + .boolean; } - static final _filterHashCode = jniLookup< - ffi - .NativeFunction)>>( - "Intent__filterHashCode") - .asFunction)>(); + static final _id_filterHashCode = _class.instanceMethodId( + r"filterHashCode", + r"()I", + ); + + static final _filterHashCode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int filterHashCode() int filterHashCode() { - return _filterHashCode(reference.pointer).integer; + return _filterHashCode( + reference.pointer, _id_filterHashCode as jni.JMethodIDPtr) + .integer; } - static final _toString1 = jniLookup< - ffi - .NativeFunction)>>( - "Intent__toString1") - .asFunction)>(); + static final _id_toString1 = _class.instanceMethodId( + r"toString", + r"()Ljava/lang/String;", + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String toString() /// The returned object must be released after use, by calling the [release] method. jni.JString toString1() { - return _toString1(reference.pointer).object(const jni.JStringType()); + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _toURI = jniLookup< + static final _id_toURI = _class.instanceMethodId( + r"toURI", + r"()Ljava/lang/String;", + ); + + static final _toURI = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Intent__toURI") - .asFunction)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String toURI() /// The returned object must be released after use, by calling the [release] method. jni.JString toURI() { - return _toURI(reference.pointer).object(const jni.JStringType()); + return _toURI(reference.pointer, _id_toURI as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _toUri = jniLookup< + static final _id_toUri = _class.instanceMethodId( + r"toUri", + r"(I)Ljava/lang/String;", + ); + + static final _toUri = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Intent__toUri") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public java.lang.String toUri(int i) /// The returned object must be released after use, by calling the [release] method. jni.JString toUri( int i, ) { - return _toUri(reference.pointer, i).object(const jni.JStringType()); + return _toUri(reference.pointer, _id_toUri as jni.JMethodIDPtr, i) + .object(const jni.JStringType()); } - static final _describeContents = jniLookup< - ffi - .NativeFunction)>>( - "Intent__describeContents") - .asFunction)>(); + static final _id_describeContents = _class.instanceMethodId( + r"describeContents", + r"()I", + ); + + static final _describeContents = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int describeContents() int describeContents() { - return _describeContents(reference.pointer).integer; + return _describeContents( + reference.pointer, _id_describeContents as jni.JMethodIDPtr) + .integer; } - static final _writeToParcel = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int32)>>("Intent__writeToParcel") + static final _id_writeToParcel = _class.instanceMethodId( + r"writeToParcel", + r"(Landroid/os/Parcel;I)V", + ); + + static final _writeToParcel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public void writeToParcel(android.os.Parcel parcel, int i) void writeToParcel( jni.JObject parcel, int i, ) { - _writeToParcel(reference.pointer, parcel.reference.pointer, i).check(); + _writeToParcel(reference.pointer, _id_writeToParcel as jni.JMethodIDPtr, + parcel.reference.pointer, i) + .check(); } - static final _readFromParcel = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Intent__readFromParcel") + static final _id_readFromParcel = _class.instanceMethodId( + r"readFromParcel", + r"(Landroid/os/Parcel;)V", + ); + + static final _readFromParcel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void readFromParcel(android.os.Parcel parcel) void readFromParcel( jni.JObject parcel, ) { - _readFromParcel(reference.pointer, parcel.reference.pointer).check(); + _readFromParcel(reference.pointer, _id_readFromParcel as jni.JMethodIDPtr, + parcel.reference.pointer) + .check(); } - static final _parseIntent = jniLookup< + static final _id_parseIntent = _class.staticMethodId( + r"parseIntent", + r"(Landroid/content/res/Resources;Lorg/xmlpull/v1/XmlPullParser;Landroid/util/AttributeSet;)Landroid/content/Intent;", + ); + + static final _parseIntent = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Intent__parseIntent") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallStaticObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); /// from: static public android.content.Intent parseIntent(android.content.res.Resources resources, org.xmlpull.v1.XmlPullParser xmlPullParser, android.util.AttributeSet attributeSet) @@ -10571,23 +14443,38 @@ class Intent extends jni.JObject { jni.JObject xmlPullParser, jni.JObject attributeSet, ) { - return _parseIntent(resources.reference.pointer, - xmlPullParser.reference.pointer, attributeSet.reference.pointer) + return _parseIntent( + _class.reference.pointer, + _id_parseIntent as jni.JMethodIDPtr, + resources.reference.pointer, + xmlPullParser.reference.pointer, + attributeSet.reference.pointer) .object(const $IntentType()); } - static final _normalizeMimeType = jniLookup< - ffi - .NativeFunction)>>( - "Intent__normalizeMimeType") - .asFunction)>(); + static final _id_normalizeMimeType = _class.staticMethodId( + r"normalizeMimeType", + r"(Ljava/lang/String;)Ljava/lang/String;", + ); + + static final _normalizeMimeType = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public java.lang.String normalizeMimeType(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. static jni.JString normalizeMimeType( jni.JString string, ) { - return _normalizeMimeType(string.reference.pointer) + return _normalizeMimeType(_class.reference.pointer, + _id_normalizeMimeType as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JStringType()); } } @@ -10623,8 +14510,10 @@ class Activity extends jni.JObject { late final jni.JObjType $type = type; Activity.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r"android/app/Activity"); /// The type which includes information such as the signature of this class. static const type = $ActivityType(); @@ -10643,15 +14532,15 @@ class Activity extends jni.JObject { /// from: static public final int DEFAULT_KEYS_SHORTCUT static const DEFAULT_KEYS_SHORTCUT = 2; - static final _get_FOCUSED_STATE_SET = - jniLookup>( - "get_Activity__FOCUSED_STATE_SET") - .asFunction(); + static final _id_FOCUSED_STATE_SET = _class.staticFieldId( + r"FOCUSED_STATE_SET", + r"[I", + ); /// from: static protected final int[] FOCUSED_STATE_SET /// The returned object must be released after use, by calling the [release] method. static jni.JArray get FOCUSED_STATE_SET => - _get_FOCUSED_STATE_SET().object(const jni.JArrayType(jni.jintType())); + _id_FOCUSED_STATE_SET.get(_class, const jni.JArrayType(jni.jintType())); /// from: static public final int RESULT_CANCELED static const RESULT_CANCELED = 0; @@ -10661,682 +14550,1234 @@ class Activity extends jni.JObject { /// from: static public final int RESULT_OK static const RESULT_OK = -1; - static final _new0 = - jniLookup>("Activity__new0") - .asFunction(); + static final _id_new0 = _class.constructorId( + r"()V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_NewObject") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void () /// The returned object must be released after use, by calling the [release] method. factory Activity() { - return Activity.fromReference(_new0().reference); + return Activity.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); } - static final _getIntent = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getIntent") - .asFunction)>(); + static final _id_getIntent = _class.instanceMethodId( + r"getIntent", + r"()Landroid/content/Intent;", + ); + + static final _getIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.Intent getIntent() /// The returned object must be released after use, by calling the [release] method. Intent getIntent() { - return _getIntent(reference.pointer).object(const $IntentType()); + return _getIntent(reference.pointer, _id_getIntent as jni.JMethodIDPtr) + .object(const $IntentType()); } - static final _setIntent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__setIntent") + static final _id_setIntent = _class.instanceMethodId( + r"setIntent", + r"(Landroid/content/Intent;)V", + ); + + static final _setIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setIntent(android.content.Intent intent) void setIntent( Intent intent, ) { - _setIntent(reference.pointer, intent.reference.pointer).check(); + _setIntent(reference.pointer, _id_setIntent as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); } - static final _setLocusContext = jniLookup< + static final _id_setLocusContext = _class.instanceMethodId( + r"setLocusContext", + r"(Landroid/content/LocusId;Landroid/os/Bundle;)V", + ); + + static final _setLocusContext = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__setLocusContext") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void setLocusContext(android.content.LocusId locusId, android.os.Bundle bundle) void setLocusContext( jni.JObject locusId, jni.JObject bundle, ) { - _setLocusContext(reference.pointer, locusId.reference.pointer, - bundle.reference.pointer) + _setLocusContext(reference.pointer, _id_setLocusContext as jni.JMethodIDPtr, + locusId.reference.pointer, bundle.reference.pointer) .check(); } - static final _getApplication = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getApplication") - .asFunction)>(); + static final _id_getApplication = _class.instanceMethodId( + r"getApplication", + r"()Landroid/app/Application;", + ); + + static final _getApplication = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final android.app.Application getApplication() /// The returned object must be released after use, by calling the [release] method. jni.JObject getApplication() { - return _getApplication(reference.pointer).object(const jni.JObjectType()); + return _getApplication( + reference.pointer, _id_getApplication as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _isChild = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isChild") - .asFunction)>(); + static final _id_isChild = _class.instanceMethodId( + r"isChild", + r"()Z", + ); + + static final _isChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final boolean isChild() bool isChild() { - return _isChild(reference.pointer).boolean; + return _isChild(reference.pointer, _id_isChild as jni.JMethodIDPtr).boolean; } - static final _getParent = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getParent") - .asFunction)>(); + static final _id_getParent = _class.instanceMethodId( + r"getParent", + r"()Landroid/app/Activity;", + ); + + static final _getParent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final android.app.Activity getParent() /// The returned object must be released after use, by calling the [release] method. Activity getParent() { - return _getParent(reference.pointer).object(const $ActivityType()); + return _getParent(reference.pointer, _id_getParent as jni.JMethodIDPtr) + .object(const $ActivityType()); } - static final _getWindowManager = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getWindowManager") - .asFunction)>(); + static final _id_getWindowManager = _class.instanceMethodId( + r"getWindowManager", + r"()Landroid/view/WindowManager;", + ); + + static final _getWindowManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.view.WindowManager getWindowManager() /// The returned object must be released after use, by calling the [release] method. jni.JObject getWindowManager() { - return _getWindowManager(reference.pointer).object(const jni.JObjectType()); + return _getWindowManager( + reference.pointer, _id_getWindowManager as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getWindow = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getWindow") - .asFunction)>(); + static final _id_getWindow = _class.instanceMethodId( + r"getWindow", + r"()Landroid/view/Window;", + ); + + static final _getWindow = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.view.Window getWindow() /// The returned object must be released after use, by calling the [release] method. jni.JObject getWindow() { - return _getWindow(reference.pointer).object(const jni.JObjectType()); + return _getWindow(reference.pointer, _id_getWindow as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getLoaderManager = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getLoaderManager") - .asFunction)>(); + static final _id_getLoaderManager = _class.instanceMethodId( + r"getLoaderManager", + r"()Landroid/app/LoaderManager;", + ); + + static final _getLoaderManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.app.LoaderManager getLoaderManager() /// The returned object must be released after use, by calling the [release] method. jni.JObject getLoaderManager() { - return _getLoaderManager(reference.pointer).object(const jni.JObjectType()); + return _getLoaderManager( + reference.pointer, _id_getLoaderManager as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getCurrentFocus = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getCurrentFocus") - .asFunction)>(); + static final _id_getCurrentFocus = _class.instanceMethodId( + r"getCurrentFocus", + r"()Landroid/view/View;", + ); + + static final _getCurrentFocus = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.view.View getCurrentFocus() /// The returned object must be released after use, by calling the [release] method. jni.JObject getCurrentFocus() { - return _getCurrentFocus(reference.pointer).object(const jni.JObjectType()); + return _getCurrentFocus( + reference.pointer, _id_getCurrentFocus as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _attachBaseContext = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__attachBaseContext") + static final _id_attachBaseContext = _class.instanceMethodId( + r"attachBaseContext", + r"(Landroid/content/Context;)V", + ); + + static final _attachBaseContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: protected void attachBaseContext(android.content.Context context) void attachBaseContext( Context context, ) { - _attachBaseContext(reference.pointer, context.reference.pointer).check(); + _attachBaseContext( + reference.pointer, + _id_attachBaseContext as jni.JMethodIDPtr, + context.reference.pointer) + .check(); } - static final _registerActivityLifecycleCallbacks = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__registerActivityLifecycleCallbacks") - .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + static final _id_registerActivityLifecycleCallbacks = _class.instanceMethodId( + r"registerActivityLifecycleCallbacks", + r"(Landroid/app/Application$ActivityLifecycleCallbacks;)V", + ); + + static final _registerActivityLifecycleCallbacks = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer)>(); /// from: public void registerActivityLifecycleCallbacks(android.app.Application$ActivityLifecycleCallbacks activityLifecycleCallbacks) void registerActivityLifecycleCallbacks( jni.JObject activityLifecycleCallbacks, ) { _registerActivityLifecycleCallbacks( - reference.pointer, activityLifecycleCallbacks.reference.pointer) + reference.pointer, + _id_registerActivityLifecycleCallbacks as jni.JMethodIDPtr, + activityLifecycleCallbacks.reference.pointer) .check(); } - static final _unregisterActivityLifecycleCallbacks = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__unregisterActivityLifecycleCallbacks") - .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + static final _id_unregisterActivityLifecycleCallbacks = + _class.instanceMethodId( + r"unregisterActivityLifecycleCallbacks", + r"(Landroid/app/Application$ActivityLifecycleCallbacks;)V", + ); + + static final _unregisterActivityLifecycleCallbacks = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer)>(); /// from: public void unregisterActivityLifecycleCallbacks(android.app.Application$ActivityLifecycleCallbacks activityLifecycleCallbacks) void unregisterActivityLifecycleCallbacks( jni.JObject activityLifecycleCallbacks, ) { _unregisterActivityLifecycleCallbacks( - reference.pointer, activityLifecycleCallbacks.reference.pointer) + reference.pointer, + _id_unregisterActivityLifecycleCallbacks as jni.JMethodIDPtr, + activityLifecycleCallbacks.reference.pointer) .check(); } - static final _registerComponentCallbacks = jniLookup< + static final _id_registerComponentCallbacks = _class.instanceMethodId( + r"registerComponentCallbacks", + r"(Landroid/content/ComponentCallbacks;)V", + ); + + static final _registerComponentCallbacks = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__registerComponentCallbacks") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void registerComponentCallbacks(android.content.ComponentCallbacks componentCallbacks) void registerComponentCallbacks( jni.JObject componentCallbacks, ) { _registerComponentCallbacks( - reference.pointer, componentCallbacks.reference.pointer) + reference.pointer, + _id_registerComponentCallbacks as jni.JMethodIDPtr, + componentCallbacks.reference.pointer) .check(); } - static final _unregisterComponentCallbacks = jniLookup< + static final _id_unregisterComponentCallbacks = _class.instanceMethodId( + r"unregisterComponentCallbacks", + r"(Landroid/content/ComponentCallbacks;)V", + ); + + static final _unregisterComponentCallbacks = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__unregisterComponentCallbacks") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void unregisterComponentCallbacks(android.content.ComponentCallbacks componentCallbacks) void unregisterComponentCallbacks( jni.JObject componentCallbacks, ) { _unregisterComponentCallbacks( - reference.pointer, componentCallbacks.reference.pointer) + reference.pointer, + _id_unregisterComponentCallbacks as jni.JMethodIDPtr, + componentCallbacks.reference.pointer) .check(); } - static final _onCreate = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onCreate") + static final _id_onCreate = _class.instanceMethodId( + r"onCreate", + r"(Landroid/os/Bundle;)V", + ); + + static final _onCreate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: protected void onCreate(android.os.Bundle bundle) void onCreate( jni.JObject bundle, ) { - _onCreate(reference.pointer, bundle.reference.pointer).check(); + _onCreate(reference.pointer, _id_onCreate as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); } - static final _getSplashScreen = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getSplashScreen") - .asFunction)>(); + static final _id_getSplashScreen = _class.instanceMethodId( + r"getSplashScreen", + r"()Landroid/window/SplashScreen;", + ); + + static final _getSplashScreen = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final android.window.SplashScreen getSplashScreen() /// The returned object must be released after use, by calling the [release] method. jni.JObject getSplashScreen() { - return _getSplashScreen(reference.pointer).object(const jni.JObjectType()); + return _getSplashScreen( + reference.pointer, _id_getSplashScreen as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _onCreate1 = jniLookup< + static final _id_onCreate1 = _class.instanceMethodId( + r"onCreate", + r"(Landroid/os/Bundle;Landroid/os/PersistableBundle;)V", + ); + + static final _onCreate1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__onCreate1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void onCreate(android.os.Bundle bundle, android.os.PersistableBundle persistableBundle) void onCreate1( jni.JObject bundle, jni.JObject persistableBundle, ) { - _onCreate1(reference.pointer, bundle.reference.pointer, - persistableBundle.reference.pointer) + _onCreate1(reference.pointer, _id_onCreate1 as jni.JMethodIDPtr, + bundle.reference.pointer, persistableBundle.reference.pointer) .check(); } - static final _onRestoreInstanceState = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onRestoreInstanceState") + static final _id_onRestoreInstanceState = _class.instanceMethodId( + r"onRestoreInstanceState", + r"(Landroid/os/Bundle;)V", + ); + + static final _onRestoreInstanceState = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: protected void onRestoreInstanceState(android.os.Bundle bundle) void onRestoreInstanceState( jni.JObject bundle, ) { - _onRestoreInstanceState(reference.pointer, bundle.reference.pointer) + _onRestoreInstanceState( + reference.pointer, + _id_onRestoreInstanceState as jni.JMethodIDPtr, + bundle.reference.pointer) .check(); } - static final _onRestoreInstanceState1 = jniLookup< + static final _id_onRestoreInstanceState1 = _class.instanceMethodId( + r"onRestoreInstanceState", + r"(Landroid/os/Bundle;Landroid/os/PersistableBundle;)V", + ); + + static final _onRestoreInstanceState1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__onRestoreInstanceState1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void onRestoreInstanceState(android.os.Bundle bundle, android.os.PersistableBundle persistableBundle) void onRestoreInstanceState1( jni.JObject bundle, jni.JObject persistableBundle, ) { - _onRestoreInstanceState1(reference.pointer, bundle.reference.pointer, + _onRestoreInstanceState1( + reference.pointer, + _id_onRestoreInstanceState1 as jni.JMethodIDPtr, + bundle.reference.pointer, persistableBundle.reference.pointer) .check(); } - static final _onPostCreate = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onPostCreate") + static final _id_onPostCreate = _class.instanceMethodId( + r"onPostCreate", + r"(Landroid/os/Bundle;)V", + ); + + static final _onPostCreate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: protected void onPostCreate(android.os.Bundle bundle) void onPostCreate( jni.JObject bundle, ) { - _onPostCreate(reference.pointer, bundle.reference.pointer).check(); + _onPostCreate(reference.pointer, _id_onPostCreate as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); } - static final _onPostCreate1 = jniLookup< + static final _id_onPostCreate1 = _class.instanceMethodId( + r"onPostCreate", + r"(Landroid/os/Bundle;Landroid/os/PersistableBundle;)V", + ); + + static final _onPostCreate1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__onPostCreate1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void onPostCreate(android.os.Bundle bundle, android.os.PersistableBundle persistableBundle) void onPostCreate1( jni.JObject bundle, jni.JObject persistableBundle, ) { - _onPostCreate1(reference.pointer, bundle.reference.pointer, - persistableBundle.reference.pointer) + _onPostCreate1(reference.pointer, _id_onPostCreate1 as jni.JMethodIDPtr, + bundle.reference.pointer, persistableBundle.reference.pointer) .check(); } - static final _onStart = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onStart") - .asFunction)>(); + static final _id_onStart = _class.instanceMethodId( + r"onStart", + r"()V", + ); + + static final _onStart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: protected void onStart() void onStart() { - _onStart(reference.pointer).check(); + _onStart(reference.pointer, _id_onStart as jni.JMethodIDPtr).check(); } - static final _onRestart = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onRestart") - .asFunction)>(); + static final _id_onRestart = _class.instanceMethodId( + r"onRestart", + r"()V", + ); + + static final _onRestart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: protected void onRestart() void onRestart() { - _onRestart(reference.pointer).check(); + _onRestart(reference.pointer, _id_onRestart as jni.JMethodIDPtr).check(); } - static final _onStateNotSaved = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onStateNotSaved") - .asFunction)>(); + static final _id_onStateNotSaved = _class.instanceMethodId( + r"onStateNotSaved", + r"()V", + ); + + static final _onStateNotSaved = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onStateNotSaved() void onStateNotSaved() { - _onStateNotSaved(reference.pointer).check(); + _onStateNotSaved(reference.pointer, _id_onStateNotSaved as jni.JMethodIDPtr) + .check(); } - static final _onResume = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onResume") - .asFunction)>(); + static final _id_onResume = _class.instanceMethodId( + r"onResume", + r"()V", + ); + + static final _onResume = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: protected void onResume() void onResume() { - _onResume(reference.pointer).check(); + _onResume(reference.pointer, _id_onResume as jni.JMethodIDPtr).check(); } - static final _onPostResume = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onPostResume") - .asFunction)>(); + static final _id_onPostResume = _class.instanceMethodId( + r"onPostResume", + r"()V", + ); + + static final _onPostResume = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: protected void onPostResume() void onPostResume() { - _onPostResume(reference.pointer).check(); + _onPostResume(reference.pointer, _id_onPostResume as jni.JMethodIDPtr) + .check(); } - static final _onTopResumedActivityChanged = jniLookup< + static final _id_onTopResumedActivityChanged = _class.instanceMethodId( + r"onTopResumedActivityChanged", + r"(Z)V", + ); + + static final _onTopResumedActivityChanged = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__onTopResumedActivityChanged") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void onTopResumedActivityChanged(boolean z) void onTopResumedActivityChanged( bool z, ) { - _onTopResumedActivityChanged(reference.pointer, z ? 1 : 0).check(); + _onTopResumedActivityChanged(reference.pointer, + _id_onTopResumedActivityChanged as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _isVoiceInteraction = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isVoiceInteraction") - .asFunction)>(); + static final _id_isVoiceInteraction = _class.instanceMethodId( + r"isVoiceInteraction", + r"()Z", + ); + + static final _isVoiceInteraction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isVoiceInteraction() bool isVoiceInteraction() { - return _isVoiceInteraction(reference.pointer).boolean; + return _isVoiceInteraction( + reference.pointer, _id_isVoiceInteraction as jni.JMethodIDPtr) + .boolean; } - static final _isVoiceInteractionRoot = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isVoiceInteractionRoot") - .asFunction)>(); + static final _id_isVoiceInteractionRoot = _class.instanceMethodId( + r"isVoiceInteractionRoot", + r"()Z", + ); + + static final _isVoiceInteractionRoot = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isVoiceInteractionRoot() bool isVoiceInteractionRoot() { - return _isVoiceInteractionRoot(reference.pointer).boolean; + return _isVoiceInteractionRoot( + reference.pointer, _id_isVoiceInteractionRoot as jni.JMethodIDPtr) + .boolean; } - static final _getVoiceInteractor = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getVoiceInteractor") - .asFunction)>(); + static final _id_getVoiceInteractor = _class.instanceMethodId( + r"getVoiceInteractor", + r"()Landroid/app/VoiceInteractor;", + ); + + static final _getVoiceInteractor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.app.VoiceInteractor getVoiceInteractor() /// The returned object must be released after use, by calling the [release] method. jni.JObject getVoiceInteractor() { - return _getVoiceInteractor(reference.pointer) + return _getVoiceInteractor( + reference.pointer, _id_getVoiceInteractor as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _isLocalVoiceInteractionSupported = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isLocalVoiceInteractionSupported") - .asFunction)>(); + static final _id_isLocalVoiceInteractionSupported = _class.instanceMethodId( + r"isLocalVoiceInteractionSupported", + r"()Z", + ); + + static final _isLocalVoiceInteractionSupported = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isLocalVoiceInteractionSupported() bool isLocalVoiceInteractionSupported() { - return _isLocalVoiceInteractionSupported(reference.pointer).boolean; + return _isLocalVoiceInteractionSupported(reference.pointer, + _id_isLocalVoiceInteractionSupported as jni.JMethodIDPtr) + .boolean; } - static final _startLocalVoiceInteraction = jniLookup< + static final _id_startLocalVoiceInteraction = _class.instanceMethodId( + r"startLocalVoiceInteraction", + r"(Landroid/os/Bundle;)V", + ); + + static final _startLocalVoiceInteraction = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__startLocalVoiceInteraction") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void startLocalVoiceInteraction(android.os.Bundle bundle) void startLocalVoiceInteraction( jni.JObject bundle, ) { - _startLocalVoiceInteraction(reference.pointer, bundle.reference.pointer) + _startLocalVoiceInteraction( + reference.pointer, + _id_startLocalVoiceInteraction as jni.JMethodIDPtr, + bundle.reference.pointer) .check(); } - static final _onLocalVoiceInteractionStarted = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onLocalVoiceInteractionStarted") - .asFunction)>(); + static final _id_onLocalVoiceInteractionStarted = _class.instanceMethodId( + r"onLocalVoiceInteractionStarted", + r"()V", + ); + + static final _onLocalVoiceInteractionStarted = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onLocalVoiceInteractionStarted() void onLocalVoiceInteractionStarted() { - _onLocalVoiceInteractionStarted(reference.pointer).check(); + _onLocalVoiceInteractionStarted(reference.pointer, + _id_onLocalVoiceInteractionStarted as jni.JMethodIDPtr) + .check(); } - static final _onLocalVoiceInteractionStopped = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onLocalVoiceInteractionStopped") - .asFunction)>(); + static final _id_onLocalVoiceInteractionStopped = _class.instanceMethodId( + r"onLocalVoiceInteractionStopped", + r"()V", + ); + + static final _onLocalVoiceInteractionStopped = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onLocalVoiceInteractionStopped() void onLocalVoiceInteractionStopped() { - _onLocalVoiceInteractionStopped(reference.pointer).check(); + _onLocalVoiceInteractionStopped(reference.pointer, + _id_onLocalVoiceInteractionStopped as jni.JMethodIDPtr) + .check(); } - static final _stopLocalVoiceInteraction = jniLookup< - ffi - .NativeFunction)>>( - "Activity__stopLocalVoiceInteraction") - .asFunction)>(); + static final _id_stopLocalVoiceInteraction = _class.instanceMethodId( + r"stopLocalVoiceInteraction", + r"()V", + ); + + static final _stopLocalVoiceInteraction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void stopLocalVoiceInteraction() void stopLocalVoiceInteraction() { - _stopLocalVoiceInteraction(reference.pointer).check(); + _stopLocalVoiceInteraction(reference.pointer, + _id_stopLocalVoiceInteraction as jni.JMethodIDPtr) + .check(); } - static final _onNewIntent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onNewIntent") + static final _id_onNewIntent = _class.instanceMethodId( + r"onNewIntent", + r"(Landroid/content/Intent;)V", + ); + + static final _onNewIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: protected void onNewIntent(android.content.Intent intent) void onNewIntent( Intent intent, ) { - _onNewIntent(reference.pointer, intent.reference.pointer).check(); + _onNewIntent(reference.pointer, _id_onNewIntent as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); } - static final _onSaveInstanceState = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onSaveInstanceState") + static final _id_onSaveInstanceState = _class.instanceMethodId( + r"onSaveInstanceState", + r"(Landroid/os/Bundle;)V", + ); + + static final _onSaveInstanceState = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: protected void onSaveInstanceState(android.os.Bundle bundle) void onSaveInstanceState( jni.JObject bundle, ) { - _onSaveInstanceState(reference.pointer, bundle.reference.pointer).check(); + _onSaveInstanceState( + reference.pointer, + _id_onSaveInstanceState as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); } - static final _onSaveInstanceState1 = jniLookup< + static final _id_onSaveInstanceState1 = _class.instanceMethodId( + r"onSaveInstanceState", + r"(Landroid/os/Bundle;Landroid/os/PersistableBundle;)V", + ); + + static final _onSaveInstanceState1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__onSaveInstanceState1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void onSaveInstanceState(android.os.Bundle bundle, android.os.PersistableBundle persistableBundle) void onSaveInstanceState1( jni.JObject bundle, jni.JObject persistableBundle, ) { - _onSaveInstanceState1(reference.pointer, bundle.reference.pointer, + _onSaveInstanceState1( + reference.pointer, + _id_onSaveInstanceState1 as jni.JMethodIDPtr, + bundle.reference.pointer, persistableBundle.reference.pointer) .check(); } - static final _onPause = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onPause") - .asFunction)>(); + static final _id_onPause = _class.instanceMethodId( + r"onPause", + r"()V", + ); + + static final _onPause = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: protected void onPause() void onPause() { - _onPause(reference.pointer).check(); + _onPause(reference.pointer, _id_onPause as jni.JMethodIDPtr).check(); } - static final _onUserLeaveHint = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onUserLeaveHint") - .asFunction)>(); + static final _id_onUserLeaveHint = _class.instanceMethodId( + r"onUserLeaveHint", + r"()V", + ); + + static final _onUserLeaveHint = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: protected void onUserLeaveHint() void onUserLeaveHint() { - _onUserLeaveHint(reference.pointer).check(); + _onUserLeaveHint(reference.pointer, _id_onUserLeaveHint as jni.JMethodIDPtr) + .check(); } - static final _onCreateThumbnail = jniLookup< + static final _id_onCreateThumbnail = _class.instanceMethodId( + r"onCreateThumbnail", + r"(Landroid/graphics/Bitmap;Landroid/graphics/Canvas;)Z", + ); + + static final _onCreateThumbnail = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__onCreateThumbnail") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public boolean onCreateThumbnail(android.graphics.Bitmap bitmap, android.graphics.Canvas canvas) bool onCreateThumbnail( jni.JObject bitmap, jni.JObject canvas, ) { - return _onCreateThumbnail(reference.pointer, bitmap.reference.pointer, + return _onCreateThumbnail( + reference.pointer, + _id_onCreateThumbnail as jni.JMethodIDPtr, + bitmap.reference.pointer, canvas.reference.pointer) .boolean; } - static final _onCreateDescription = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onCreateDescription") - .asFunction)>(); + static final _id_onCreateDescription = _class.instanceMethodId( + r"onCreateDescription", + r"()Ljava/lang/CharSequence;", + ); + + static final _onCreateDescription = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.CharSequence onCreateDescription() /// The returned object must be released after use, by calling the [release] method. jni.JObject onCreateDescription() { - return _onCreateDescription(reference.pointer) + return _onCreateDescription( + reference.pointer, _id_onCreateDescription as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _onProvideAssistData = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onProvideAssistData") + static final _id_onProvideAssistData = _class.instanceMethodId( + r"onProvideAssistData", + r"(Landroid/os/Bundle;)V", + ); + + static final _onProvideAssistData = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onProvideAssistData(android.os.Bundle bundle) void onProvideAssistData( jni.JObject bundle, ) { - _onProvideAssistData(reference.pointer, bundle.reference.pointer).check(); + _onProvideAssistData( + reference.pointer, + _id_onProvideAssistData as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); } - static final _onProvideAssistContent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onProvideAssistContent") + static final _id_onProvideAssistContent = _class.instanceMethodId( + r"onProvideAssistContent", + r"(Landroid/app/assist/AssistContent;)V", + ); + + static final _onProvideAssistContent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onProvideAssistContent(android.app.assist.AssistContent assistContent) void onProvideAssistContent( jni.JObject assistContent, ) { - _onProvideAssistContent(reference.pointer, assistContent.reference.pointer) + _onProvideAssistContent( + reference.pointer, + _id_onProvideAssistContent as jni.JMethodIDPtr, + assistContent.reference.pointer) .check(); } - static final _onGetDirectActions = jniLookup< + static final _id_onGetDirectActions = _class.instanceMethodId( + r"onGetDirectActions", + r"(Landroid/os/CancellationSignal;Ljava/util/function/Consumer;)V", + ); + + static final _onGetDirectActions = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__onGetDirectActions") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void onGetDirectActions(android.os.CancellationSignal cancellationSignal, java.util.function.Consumer consumer) void onGetDirectActions( jni.JObject cancellationSignal, jni.JObject consumer, ) { - _onGetDirectActions(reference.pointer, cancellationSignal.reference.pointer, + _onGetDirectActions( + reference.pointer, + _id_onGetDirectActions as jni.JMethodIDPtr, + cancellationSignal.reference.pointer, consumer.reference.pointer) .check(); } - static final _onPerformDirectAction = jniLookup< + static final _id_onPerformDirectAction = _class.instanceMethodId( + r"onPerformDirectAction", + r"(Ljava/lang/String;Landroid/os/Bundle;Landroid/os/CancellationSignal;Ljava/util/function/Consumer;)V", + ); + + static final _onPerformDirectAction = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__onPerformDirectAction") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -11351,6 +15792,7 @@ class Activity extends jni.JObject { ) { _onPerformDirectAction( reference.pointer, + _id_onPerformDirectAction as jni.JMethodIDPtr, string.reference.pointer, bundle.reference.pointer, cancellationSignal.reference.pointer, @@ -11358,38 +15800,73 @@ class Activity extends jni.JObject { .check(); } - static final _requestShowKeyboardShortcuts = jniLookup< - ffi - .NativeFunction)>>( - "Activity__requestShowKeyboardShortcuts") - .asFunction)>(); + static final _id_requestShowKeyboardShortcuts = _class.instanceMethodId( + r"requestShowKeyboardShortcuts", + r"()V", + ); + + static final _requestShowKeyboardShortcuts = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final void requestShowKeyboardShortcuts() void requestShowKeyboardShortcuts() { - _requestShowKeyboardShortcuts(reference.pointer).check(); + _requestShowKeyboardShortcuts(reference.pointer, + _id_requestShowKeyboardShortcuts as jni.JMethodIDPtr) + .check(); } - static final _dismissKeyboardShortcutsHelper = jniLookup< - ffi - .NativeFunction)>>( - "Activity__dismissKeyboardShortcutsHelper") - .asFunction)>(); + static final _id_dismissKeyboardShortcutsHelper = _class.instanceMethodId( + r"dismissKeyboardShortcutsHelper", + r"()V", + ); + + static final _dismissKeyboardShortcutsHelper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final void dismissKeyboardShortcutsHelper() void dismissKeyboardShortcutsHelper() { - _dismissKeyboardShortcutsHelper(reference.pointer).check(); + _dismissKeyboardShortcutsHelper(reference.pointer, + _id_dismissKeyboardShortcutsHelper as jni.JMethodIDPtr) + .check(); } - static final _onProvideKeyboardShortcuts = jniLookup< + static final _id_onProvideKeyboardShortcuts = _class.instanceMethodId( + r"onProvideKeyboardShortcuts", + r"(Ljava/util/List;Landroid/view/Menu;I)V", + ); + + static final _onProvideKeyboardShortcuts = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__onProvideKeyboardShortcuts") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); /// from: public void onProvideKeyboardShortcuts(java.util.List list, android.view.Menu menu, int i) void onProvideKeyboardShortcuts( @@ -11397,66 +15874,123 @@ class Activity extends jni.JObject { jni.JObject menu, int i, ) { - _onProvideKeyboardShortcuts(reference.pointer, list.reference.pointer, - menu.reference.pointer, i) + _onProvideKeyboardShortcuts( + reference.pointer, + _id_onProvideKeyboardShortcuts as jni.JMethodIDPtr, + list.reference.pointer, + menu.reference.pointer, + i) .check(); } - static final _showAssist = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__showAssist") + static final _id_showAssist = _class.instanceMethodId( + r"showAssist", + r"(Landroid/os/Bundle;)Z", + ); + + static final _showAssist = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean showAssist(android.os.Bundle bundle) bool showAssist( jni.JObject bundle, ) { - return _showAssist(reference.pointer, bundle.reference.pointer).boolean; + return _showAssist(reference.pointer, _id_showAssist as jni.JMethodIDPtr, + bundle.reference.pointer) + .boolean; } - static final _onStop = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onStop") - .asFunction)>(); + static final _id_onStop = _class.instanceMethodId( + r"onStop", + r"()V", + ); + + static final _onStop = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: protected void onStop() void onStop() { - _onStop(reference.pointer).check(); + _onStop(reference.pointer, _id_onStop as jni.JMethodIDPtr).check(); } - static final _onDestroy = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onDestroy") - .asFunction)>(); + static final _id_onDestroy = _class.instanceMethodId( + r"onDestroy", + r"()V", + ); + + static final _onDestroy = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: protected void onDestroy() void onDestroy() { - _onDestroy(reference.pointer).check(); + _onDestroy(reference.pointer, _id_onDestroy as jni.JMethodIDPtr).check(); } - static final _reportFullyDrawn = jniLookup< - ffi - .NativeFunction)>>( - "Activity__reportFullyDrawn") - .asFunction)>(); + static final _id_reportFullyDrawn = _class.instanceMethodId( + r"reportFullyDrawn", + r"()V", + ); + + static final _reportFullyDrawn = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void reportFullyDrawn() void reportFullyDrawn() { - _reportFullyDrawn(reference.pointer).check(); + _reportFullyDrawn( + reference.pointer, _id_reportFullyDrawn as jni.JMethodIDPtr) + .check(); } - static final _onMultiWindowModeChanged = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Uint8, - ffi.Pointer)>>("Activity__onMultiWindowModeChanged") + static final _id_onMultiWindowModeChanged = _class.instanceMethodId( + r"onMultiWindowModeChanged", + r"(ZLandroid/content/res/Configuration;)V", + ); + + static final _onMultiWindowModeChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: public void onMultiWindowModeChanged(boolean z, android.content.res.Configuration configuration) void onMultiWindowModeChanged( @@ -11464,42 +15998,76 @@ class Activity extends jni.JObject { jni.JObject configuration, ) { _onMultiWindowModeChanged( - reference.pointer, z ? 1 : 0, configuration.reference.pointer) + reference.pointer, + _id_onMultiWindowModeChanged as jni.JMethodIDPtr, + z ? 1 : 0, + configuration.reference.pointer) .check(); } - static final _onMultiWindowModeChanged1 = jniLookup< + static final _id_onMultiWindowModeChanged1 = _class.instanceMethodId( + r"onMultiWindowModeChanged", + r"(Z)V", + ); + + static final _onMultiWindowModeChanged1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__onMultiWindowModeChanged1") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void onMultiWindowModeChanged(boolean z) void onMultiWindowModeChanged1( bool z, ) { - _onMultiWindowModeChanged1(reference.pointer, z ? 1 : 0).check(); + _onMultiWindowModeChanged1(reference.pointer, + _id_onMultiWindowModeChanged1 as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _isInMultiWindowMode = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isInMultiWindowMode") - .asFunction)>(); + static final _id_isInMultiWindowMode = _class.instanceMethodId( + r"isInMultiWindowMode", + r"()Z", + ); + + static final _isInMultiWindowMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isInMultiWindowMode() bool isInMultiWindowMode() { - return _isInMultiWindowMode(reference.pointer).boolean; + return _isInMultiWindowMode( + reference.pointer, _id_isInMultiWindowMode as jni.JMethodIDPtr) + .boolean; } - static final _onPictureInPictureModeChanged = jniLookup< + static final _id_onPictureInPictureModeChanged = _class.instanceMethodId( + r"onPictureInPictureModeChanged", + r"(ZLandroid/content/res/Configuration;)V", + ); + + static final _onPictureInPictureModeChanged = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Uint8, - ffi.Pointer)>>( - "Activity__onPictureInPictureModeChanged") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: public void onPictureInPictureModeChanged(boolean z, android.content.res.Configuration configuration) void onPictureInPictureModeChanged( @@ -11507,262 +16075,486 @@ class Activity extends jni.JObject { jni.JObject configuration, ) { _onPictureInPictureModeChanged( - reference.pointer, z ? 1 : 0, configuration.reference.pointer) + reference.pointer, + _id_onPictureInPictureModeChanged as jni.JMethodIDPtr, + z ? 1 : 0, + configuration.reference.pointer) .check(); } - static final _onPictureInPictureUiStateChanged = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__onPictureInPictureUiStateChanged") - .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + static final _id_onPictureInPictureUiStateChanged = _class.instanceMethodId( + r"onPictureInPictureUiStateChanged", + r"(Landroid/app/PictureInPictureUiState;)V", + ); + + static final _onPictureInPictureUiStateChanged = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer)>(); /// from: public void onPictureInPictureUiStateChanged(android.app.PictureInPictureUiState pictureInPictureUiState) void onPictureInPictureUiStateChanged( jni.JObject pictureInPictureUiState, ) { _onPictureInPictureUiStateChanged( - reference.pointer, pictureInPictureUiState.reference.pointer) + reference.pointer, + _id_onPictureInPictureUiStateChanged as jni.JMethodIDPtr, + pictureInPictureUiState.reference.pointer) .check(); } - static final _onPictureInPictureModeChanged1 = jniLookup< + static final _id_onPictureInPictureModeChanged1 = _class.instanceMethodId( + r"onPictureInPictureModeChanged", + r"(Z)V", + ); + + static final _onPictureInPictureModeChanged1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__onPictureInPictureModeChanged1") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void onPictureInPictureModeChanged(boolean z) void onPictureInPictureModeChanged1( bool z, ) { - _onPictureInPictureModeChanged1(reference.pointer, z ? 1 : 0).check(); + _onPictureInPictureModeChanged1(reference.pointer, + _id_onPictureInPictureModeChanged1 as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _isInPictureInPictureMode = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isInPictureInPictureMode") - .asFunction)>(); + static final _id_isInPictureInPictureMode = _class.instanceMethodId( + r"isInPictureInPictureMode", + r"()Z", + ); + + static final _isInPictureInPictureMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isInPictureInPictureMode() bool isInPictureInPictureMode() { - return _isInPictureInPictureMode(reference.pointer).boolean; + return _isInPictureInPictureMode( + reference.pointer, _id_isInPictureInPictureMode as jni.JMethodIDPtr) + .boolean; } - static final _enterPictureInPictureMode = jniLookup< - ffi - .NativeFunction)>>( - "Activity__enterPictureInPictureMode") - .asFunction)>(); + static final _id_enterPictureInPictureMode = _class.instanceMethodId( + r"enterPictureInPictureMode", + r"()V", + ); + + static final _enterPictureInPictureMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void enterPictureInPictureMode() void enterPictureInPictureMode() { - _enterPictureInPictureMode(reference.pointer).check(); + _enterPictureInPictureMode(reference.pointer, + _id_enterPictureInPictureMode as jni.JMethodIDPtr) + .check(); } - static final _enterPictureInPictureMode1 = jniLookup< + static final _id_enterPictureInPictureMode1 = _class.instanceMethodId( + r"enterPictureInPictureMode", + r"(Landroid/app/PictureInPictureParams;)Z", + ); + + static final _enterPictureInPictureMode1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__enterPictureInPictureMode1") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean enterPictureInPictureMode(android.app.PictureInPictureParams pictureInPictureParams) bool enterPictureInPictureMode1( jni.JObject pictureInPictureParams, ) { return _enterPictureInPictureMode1( - reference.pointer, pictureInPictureParams.reference.pointer) + reference.pointer, + _id_enterPictureInPictureMode1 as jni.JMethodIDPtr, + pictureInPictureParams.reference.pointer) .boolean; } - static final _setPictureInPictureParams = jniLookup< + static final _id_setPictureInPictureParams = _class.instanceMethodId( + r"setPictureInPictureParams", + r"(Landroid/app/PictureInPictureParams;)V", + ); + + static final _setPictureInPictureParams = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__setPictureInPictureParams") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setPictureInPictureParams(android.app.PictureInPictureParams pictureInPictureParams) void setPictureInPictureParams( jni.JObject pictureInPictureParams, ) { _setPictureInPictureParams( - reference.pointer, pictureInPictureParams.reference.pointer) + reference.pointer, + _id_setPictureInPictureParams as jni.JMethodIDPtr, + pictureInPictureParams.reference.pointer) .check(); } - static final _getMaxNumPictureInPictureActions = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getMaxNumPictureInPictureActions") - .asFunction)>(); + static final _id_getMaxNumPictureInPictureActions = _class.instanceMethodId( + r"getMaxNumPictureInPictureActions", + r"()I", + ); + + static final _getMaxNumPictureInPictureActions = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int getMaxNumPictureInPictureActions() int getMaxNumPictureInPictureActions() { - return _getMaxNumPictureInPictureActions(reference.pointer).integer; + return _getMaxNumPictureInPictureActions(reference.pointer, + _id_getMaxNumPictureInPictureActions as jni.JMethodIDPtr) + .integer; } - static final _onPictureInPictureRequested = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onPictureInPictureRequested") - .asFunction)>(); + static final _id_onPictureInPictureRequested = _class.instanceMethodId( + r"onPictureInPictureRequested", + r"()Z", + ); + + static final _onPictureInPictureRequested = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean onPictureInPictureRequested() bool onPictureInPictureRequested() { - return _onPictureInPictureRequested(reference.pointer).boolean; + return _onPictureInPictureRequested(reference.pointer, + _id_onPictureInPictureRequested as jni.JMethodIDPtr) + .boolean; } - static final _setShouldDockBigOverlays = jniLookup< + static final _id_setShouldDockBigOverlays = _class.instanceMethodId( + r"setShouldDockBigOverlays", + r"(Z)V", + ); + + static final _setShouldDockBigOverlays = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setShouldDockBigOverlays") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setShouldDockBigOverlays(boolean z) void setShouldDockBigOverlays( bool z, ) { - _setShouldDockBigOverlays(reference.pointer, z ? 1 : 0).check(); + _setShouldDockBigOverlays(reference.pointer, + _id_setShouldDockBigOverlays as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _shouldDockBigOverlays = jniLookup< - ffi - .NativeFunction)>>( - "Activity__shouldDockBigOverlays") - .asFunction)>(); + static final _id_shouldDockBigOverlays = _class.instanceMethodId( + r"shouldDockBigOverlays", + r"()Z", + ); + + static final _shouldDockBigOverlays = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean shouldDockBigOverlays() bool shouldDockBigOverlays() { - return _shouldDockBigOverlays(reference.pointer).boolean; + return _shouldDockBigOverlays( + reference.pointer, _id_shouldDockBigOverlays as jni.JMethodIDPtr) + .boolean; } - static final _onConfigurationChanged = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onConfigurationChanged") + static final _id_onConfigurationChanged = _class.instanceMethodId( + r"onConfigurationChanged", + r"(Landroid/content/res/Configuration;)V", + ); + + static final _onConfigurationChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onConfigurationChanged(android.content.res.Configuration configuration) void onConfigurationChanged( jni.JObject configuration, ) { - _onConfigurationChanged(reference.pointer, configuration.reference.pointer) + _onConfigurationChanged( + reference.pointer, + _id_onConfigurationChanged as jni.JMethodIDPtr, + configuration.reference.pointer) .check(); } - static final _getChangingConfigurations = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getChangingConfigurations") - .asFunction)>(); + static final _id_getChangingConfigurations = _class.instanceMethodId( + r"getChangingConfigurations", + r"()I", + ); + + static final _getChangingConfigurations = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int getChangingConfigurations() int getChangingConfigurations() { - return _getChangingConfigurations(reference.pointer).integer; + return _getChangingConfigurations(reference.pointer, + _id_getChangingConfigurations as jni.JMethodIDPtr) + .integer; } - static final _getLastNonConfigurationInstance = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getLastNonConfigurationInstance") - .asFunction)>(); + static final _id_getLastNonConfigurationInstance = _class.instanceMethodId( + r"getLastNonConfigurationInstance", + r"()Ljava/lang/Object;", + ); + + static final _getLastNonConfigurationInstance = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.Object getLastNonConfigurationInstance() /// The returned object must be released after use, by calling the [release] method. jni.JObject getLastNonConfigurationInstance() { - return _getLastNonConfigurationInstance(reference.pointer) + return _getLastNonConfigurationInstance(reference.pointer, + _id_getLastNonConfigurationInstance as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _onRetainNonConfigurationInstance = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onRetainNonConfigurationInstance") - .asFunction)>(); + static final _id_onRetainNonConfigurationInstance = _class.instanceMethodId( + r"onRetainNonConfigurationInstance", + r"()Ljava/lang/Object;", + ); + + static final _onRetainNonConfigurationInstance = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.Object onRetainNonConfigurationInstance() /// The returned object must be released after use, by calling the [release] method. jni.JObject onRetainNonConfigurationInstance() { - return _onRetainNonConfigurationInstance(reference.pointer) + return _onRetainNonConfigurationInstance(reference.pointer, + _id_onRetainNonConfigurationInstance as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _onLowMemory = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onLowMemory") - .asFunction)>(); + static final _id_onLowMemory = _class.instanceMethodId( + r"onLowMemory", + r"()V", + ); + + static final _onLowMemory = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onLowMemory() void onLowMemory() { - _onLowMemory(reference.pointer).check(); + _onLowMemory(reference.pointer, _id_onLowMemory as jni.JMethodIDPtr) + .check(); } - static final _onTrimMemory = jniLookup< + static final _id_onTrimMemory = _class.instanceMethodId( + r"onTrimMemory", + r"(I)V", + ); + + static final _onTrimMemory = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__onTrimMemory") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void onTrimMemory(int i) void onTrimMemory( int i, ) { - _onTrimMemory(reference.pointer, i).check(); + _onTrimMemory(reference.pointer, _id_onTrimMemory as jni.JMethodIDPtr, i) + .check(); } - static final _getFragmentManager = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getFragmentManager") - .asFunction)>(); + static final _id_getFragmentManager = _class.instanceMethodId( + r"getFragmentManager", + r"()Landroid/app/FragmentManager;", + ); + + static final _getFragmentManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.app.FragmentManager getFragmentManager() /// The returned object must be released after use, by calling the [release] method. jni.JObject getFragmentManager() { - return _getFragmentManager(reference.pointer) + return _getFragmentManager( + reference.pointer, _id_getFragmentManager as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _onAttachFragment = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onAttachFragment") + static final _id_onAttachFragment = _class.instanceMethodId( + r"onAttachFragment", + r"(Landroid/app/Fragment;)V", + ); + + static final _onAttachFragment = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onAttachFragment(android.app.Fragment fragment) void onAttachFragment( jni.JObject fragment, ) { - _onAttachFragment(reference.pointer, fragment.reference.pointer).check(); + _onAttachFragment( + reference.pointer, + _id_onAttachFragment as jni.JMethodIDPtr, + fragment.reference.pointer) + .check(); } - static final _managedQuery = jniLookup< + static final _id_managedQuery = _class.instanceMethodId( + r"managedQuery", + r"(Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)Landroid/database/Cursor;", + ); + + static final _managedQuery = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__managedQuery") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< jni.JniResult Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -11780,6 +16572,7 @@ class Activity extends jni.JObject { ) { return _managedQuery( reference.pointer, + _id_managedQuery as jni.JMethodIDPtr, uri.reference.pointer, strings.reference.pointer, string.reference.pointer, @@ -11788,41 +16581,72 @@ class Activity extends jni.JObject { .object(const jni.JObjectType()); } - static final _startManagingCursor = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__startManagingCursor") + static final _id_startManagingCursor = _class.instanceMethodId( + r"startManagingCursor", + r"(Landroid/database/Cursor;)V", + ); + + static final _startManagingCursor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void startManagingCursor(android.database.Cursor cursor) void startManagingCursor( jni.JObject cursor, ) { - _startManagingCursor(reference.pointer, cursor.reference.pointer).check(); + _startManagingCursor( + reference.pointer, + _id_startManagingCursor as jni.JMethodIDPtr, + cursor.reference.pointer) + .check(); } - static final _stopManagingCursor = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__stopManagingCursor") + static final _id_stopManagingCursor = _class.instanceMethodId( + r"stopManagingCursor", + r"(Landroid/database/Cursor;)V", + ); + + static final _stopManagingCursor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void stopManagingCursor(android.database.Cursor cursor) void stopManagingCursor( jni.JObject cursor, ) { - _stopManagingCursor(reference.pointer, cursor.reference.pointer).check(); + _stopManagingCursor( + reference.pointer, + _id_stopManagingCursor as jni.JMethodIDPtr, + cursor.reference.pointer) + .check(); } - static final _findViewById = jniLookup< + static final _id_findViewById = _class.instanceMethodId( + r"findViewById", + r"(I)Landroid/view/View;", + ); + + static final _findViewById = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__findViewById") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public T findViewById(int i) /// The returned object must be released after use, by calling the [release] method. @@ -11830,14 +16654,23 @@ class Activity extends jni.JObject { int i, { required jni.JObjType<$T> T, }) { - return _findViewById(reference.pointer, i).object(T); + return _findViewById( + reference.pointer, _id_findViewById as jni.JMethodIDPtr, i) + .object(T); } - static final _requireViewById = jniLookup< + static final _id_requireViewById = _class.instanceMethodId( + r"requireViewById", + r"(I)Landroid/view/View;", + ); + + static final _requireViewById = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__requireViewById") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final T requireViewById(int i) /// The returned object must be released after use, by calling the [release] method. @@ -11845,229 +16678,393 @@ class Activity extends jni.JObject { int i, { required jni.JObjType<$T> T, }) { - return _requireViewById(reference.pointer, i).object(T); + return _requireViewById( + reference.pointer, _id_requireViewById as jni.JMethodIDPtr, i) + .object(T); } - static final _getActionBar = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getActionBar") - .asFunction)>(); + static final _id_getActionBar = _class.instanceMethodId( + r"getActionBar", + r"()Landroid/app/ActionBar;", + ); + + static final _getActionBar = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.app.ActionBar getActionBar() /// The returned object must be released after use, by calling the [release] method. jni.JObject getActionBar() { - return _getActionBar(reference.pointer).object(const jni.JObjectType()); + return _getActionBar( + reference.pointer, _id_getActionBar as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _setActionBar = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__setActionBar") + static final _id_setActionBar = _class.instanceMethodId( + r"setActionBar", + r"(Landroid/widget/Toolbar;)V", + ); + + static final _setActionBar = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setActionBar(android.widget.Toolbar toolbar) void setActionBar( jni.JObject toolbar, ) { - _setActionBar(reference.pointer, toolbar.reference.pointer).check(); + _setActionBar(reference.pointer, _id_setActionBar as jni.JMethodIDPtr, + toolbar.reference.pointer) + .check(); } - static final _setContentView = jniLookup< + static final _id_setContentView = _class.instanceMethodId( + r"setContentView", + r"(I)V", + ); + + static final _setContentView = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__setContentView") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setContentView(int i) void setContentView( int i, ) { - _setContentView(reference.pointer, i).check(); + _setContentView( + reference.pointer, _id_setContentView as jni.JMethodIDPtr, i) + .check(); } - static final _setContentView1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__setContentView1") + static final _id_setContentView1 = _class.instanceMethodId( + r"setContentView", + r"(Landroid/view/View;)V", + ); + + static final _setContentView1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setContentView(android.view.View view) void setContentView1( jni.JObject view, ) { - _setContentView1(reference.pointer, view.reference.pointer).check(); + _setContentView1(reference.pointer, _id_setContentView1 as jni.JMethodIDPtr, + view.reference.pointer) + .check(); } - static final _setContentView2 = jniLookup< + static final _id_setContentView2 = _class.instanceMethodId( + r"setContentView", + r"(Landroid/view/View;Landroid/view/ViewGroup$LayoutParams;)V", + ); + + static final _setContentView2 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__setContentView2") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void setContentView(android.view.View view, android.view.ViewGroup$LayoutParams layoutParams) void setContentView2( jni.JObject view, jni.JObject layoutParams, ) { - _setContentView2(reference.pointer, view.reference.pointer, - layoutParams.reference.pointer) + _setContentView2(reference.pointer, _id_setContentView2 as jni.JMethodIDPtr, + view.reference.pointer, layoutParams.reference.pointer) .check(); } - static final _addContentView = jniLookup< + static final _id_addContentView = _class.instanceMethodId( + r"addContentView", + r"(Landroid/view/View;Landroid/view/ViewGroup$LayoutParams;)V", + ); + + static final _addContentView = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__addContentView") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void addContentView(android.view.View view, android.view.ViewGroup$LayoutParams layoutParams) void addContentView( jni.JObject view, jni.JObject layoutParams, ) { - _addContentView(reference.pointer, view.reference.pointer, - layoutParams.reference.pointer) + _addContentView(reference.pointer, _id_addContentView as jni.JMethodIDPtr, + view.reference.pointer, layoutParams.reference.pointer) .check(); } - static final _getContentTransitionManager = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getContentTransitionManager") - .asFunction)>(); + static final _id_getContentTransitionManager = _class.instanceMethodId( + r"getContentTransitionManager", + r"()Landroid/transition/TransitionManager;", + ); + + static final _getContentTransitionManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.transition.TransitionManager getContentTransitionManager() /// The returned object must be released after use, by calling the [release] method. jni.JObject getContentTransitionManager() { - return _getContentTransitionManager(reference.pointer) + return _getContentTransitionManager(reference.pointer, + _id_getContentTransitionManager as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _setContentTransitionManager = jniLookup< + static final _id_setContentTransitionManager = _class.instanceMethodId( + r"setContentTransitionManager", + r"(Landroid/transition/TransitionManager;)V", + ); + + static final _setContentTransitionManager = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__setContentTransitionManager") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setContentTransitionManager(android.transition.TransitionManager transitionManager) void setContentTransitionManager( jni.JObject transitionManager, ) { _setContentTransitionManager( - reference.pointer, transitionManager.reference.pointer) + reference.pointer, + _id_setContentTransitionManager as jni.JMethodIDPtr, + transitionManager.reference.pointer) .check(); } - static final _getContentScene = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getContentScene") - .asFunction)>(); + static final _id_getContentScene = _class.instanceMethodId( + r"getContentScene", + r"()Landroid/transition/Scene;", + ); + + static final _getContentScene = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.transition.Scene getContentScene() /// The returned object must be released after use, by calling the [release] method. jni.JObject getContentScene() { - return _getContentScene(reference.pointer).object(const jni.JObjectType()); + return _getContentScene( + reference.pointer, _id_getContentScene as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _setFinishOnTouchOutside = jniLookup< + static final _id_setFinishOnTouchOutside = _class.instanceMethodId( + r"setFinishOnTouchOutside", + r"(Z)V", + ); + + static final _setFinishOnTouchOutside = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setFinishOnTouchOutside") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setFinishOnTouchOutside(boolean z) void setFinishOnTouchOutside( bool z, ) { - _setFinishOnTouchOutside(reference.pointer, z ? 1 : 0).check(); + _setFinishOnTouchOutside(reference.pointer, + _id_setFinishOnTouchOutside as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _setDefaultKeyMode = jniLookup< + static final _id_setDefaultKeyMode = _class.instanceMethodId( + r"setDefaultKeyMode", + r"(I)V", + ); + + static final _setDefaultKeyMode = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__setDefaultKeyMode") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void setDefaultKeyMode(int i) void setDefaultKeyMode( int i, ) { - _setDefaultKeyMode(reference.pointer, i).check(); + _setDefaultKeyMode( + reference.pointer, _id_setDefaultKeyMode as jni.JMethodIDPtr, i) + .check(); } - static final _onKeyDown = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onKeyDown") + static final _id_onKeyDown = _class.instanceMethodId( + r"onKeyDown", + r"(ILandroid/view/KeyEvent;)Z", + ); + + static final _onKeyDown = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public boolean onKeyDown(int i, android.view.KeyEvent keyEvent) bool onKeyDown( int i, jni.JObject keyEvent, ) { - return _onKeyDown(reference.pointer, i, keyEvent.reference.pointer).boolean; + return _onKeyDown(reference.pointer, _id_onKeyDown as jni.JMethodIDPtr, i, + keyEvent.reference.pointer) + .boolean; } - static final _onKeyLongPress = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onKeyLongPress") + static final _id_onKeyLongPress = _class.instanceMethodId( + r"onKeyLongPress", + r"(ILandroid/view/KeyEvent;)Z", + ); + + static final _onKeyLongPress = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public boolean onKeyLongPress(int i, android.view.KeyEvent keyEvent) bool onKeyLongPress( int i, jni.JObject keyEvent, ) { - return _onKeyLongPress(reference.pointer, i, keyEvent.reference.pointer) + return _onKeyLongPress( + reference.pointer, + _id_onKeyLongPress as jni.JMethodIDPtr, + i, + keyEvent.reference.pointer) .boolean; } - static final _onKeyUp = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onKeyUp") + static final _id_onKeyUp = _class.instanceMethodId( + r"onKeyUp", + r"(ILandroid/view/KeyEvent;)Z", + ); + + static final _onKeyUp = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public boolean onKeyUp(int i, android.view.KeyEvent keyEvent) bool onKeyUp( int i, jni.JObject keyEvent, ) { - return _onKeyUp(reference.pointer, i, keyEvent.reference.pointer).boolean; + return _onKeyUp(reference.pointer, _id_onKeyUp as jni.JMethodIDPtr, i, + keyEvent.reference.pointer) + .boolean; } - static final _onKeyMultiple = jniLookup< + static final _id_onKeyMultiple = _class.instanceMethodId( + r"onKeyMultiple", + r"(IILandroid/view/KeyEvent;)Z", + ); + + static final _onKeyMultiple = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Int32, ffi.Pointer)>>("Activity__onKeyMultiple") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + int, ffi.Pointer)>(); /// from: public boolean onKeyMultiple(int i, int i1, android.view.KeyEvent keyEvent) bool onKeyMultiple( @@ -12075,316 +17072,550 @@ class Activity extends jni.JObject { int i1, jni.JObject keyEvent, ) { - return _onKeyMultiple(reference.pointer, i, i1, keyEvent.reference.pointer) + return _onKeyMultiple( + reference.pointer, + _id_onKeyMultiple as jni.JMethodIDPtr, + i, + i1, + keyEvent.reference.pointer) .boolean; } - static final _onBackPressed = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onBackPressed") - .asFunction)>(); + static final _id_onBackPressed = _class.instanceMethodId( + r"onBackPressed", + r"()V", + ); + + static final _onBackPressed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onBackPressed() void onBackPressed() { - _onBackPressed(reference.pointer).check(); + _onBackPressed(reference.pointer, _id_onBackPressed as jni.JMethodIDPtr) + .check(); } - static final _onKeyShortcut = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onKeyShortcut") + static final _id_onKeyShortcut = _class.instanceMethodId( + r"onKeyShortcut", + r"(ILandroid/view/KeyEvent;)Z", + ); + + static final _onKeyShortcut = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public boolean onKeyShortcut(int i, android.view.KeyEvent keyEvent) bool onKeyShortcut( int i, jni.JObject keyEvent, ) { - return _onKeyShortcut(reference.pointer, i, keyEvent.reference.pointer) + return _onKeyShortcut( + reference.pointer, + _id_onKeyShortcut as jni.JMethodIDPtr, + i, + keyEvent.reference.pointer) .boolean; } - static final _onTouchEvent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onTouchEvent") + static final _id_onTouchEvent = _class.instanceMethodId( + r"onTouchEvent", + r"(Landroid/view/MotionEvent;)Z", + ); + + static final _onTouchEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onTouchEvent(android.view.MotionEvent motionEvent) bool onTouchEvent( jni.JObject motionEvent, ) { - return _onTouchEvent(reference.pointer, motionEvent.reference.pointer) + return _onTouchEvent(reference.pointer, + _id_onTouchEvent as jni.JMethodIDPtr, motionEvent.reference.pointer) .boolean; } - static final _onTrackballEvent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onTrackballEvent") + static final _id_onTrackballEvent = _class.instanceMethodId( + r"onTrackballEvent", + r"(Landroid/view/MotionEvent;)Z", + ); + + static final _onTrackballEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onTrackballEvent(android.view.MotionEvent motionEvent) bool onTrackballEvent( jni.JObject motionEvent, ) { - return _onTrackballEvent(reference.pointer, motionEvent.reference.pointer) + return _onTrackballEvent( + reference.pointer, + _id_onTrackballEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) .boolean; } - static final _onGenericMotionEvent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onGenericMotionEvent") + static final _id_onGenericMotionEvent = _class.instanceMethodId( + r"onGenericMotionEvent", + r"(Landroid/view/MotionEvent;)Z", + ); + + static final _onGenericMotionEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onGenericMotionEvent(android.view.MotionEvent motionEvent) bool onGenericMotionEvent( jni.JObject motionEvent, ) { return _onGenericMotionEvent( - reference.pointer, motionEvent.reference.pointer) + reference.pointer, + _id_onGenericMotionEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) .boolean; } - static final _onUserInteraction = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onUserInteraction") - .asFunction)>(); + static final _id_onUserInteraction = _class.instanceMethodId( + r"onUserInteraction", + r"()V", + ); + + static final _onUserInteraction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onUserInteraction() void onUserInteraction() { - _onUserInteraction(reference.pointer).check(); + _onUserInteraction( + reference.pointer, _id_onUserInteraction as jni.JMethodIDPtr) + .check(); } - static final _onWindowAttributesChanged = jniLookup< + static final _id_onWindowAttributesChanged = _class.instanceMethodId( + r"onWindowAttributesChanged", + r"(Landroid/view/WindowManager$LayoutParams;)V", + ); + + static final _onWindowAttributesChanged = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__onWindowAttributesChanged") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onWindowAttributesChanged(android.view.WindowManager$LayoutParams layoutParams) void onWindowAttributesChanged( jni.JObject layoutParams, ) { _onWindowAttributesChanged( - reference.pointer, layoutParams.reference.pointer) + reference.pointer, + _id_onWindowAttributesChanged as jni.JMethodIDPtr, + layoutParams.reference.pointer) .check(); } - static final _onContentChanged = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onContentChanged") - .asFunction)>(); + static final _id_onContentChanged = _class.instanceMethodId( + r"onContentChanged", + r"()V", + ); + + static final _onContentChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onContentChanged() void onContentChanged() { - _onContentChanged(reference.pointer).check(); + _onContentChanged( + reference.pointer, _id_onContentChanged as jni.JMethodIDPtr) + .check(); } - static final _onWindowFocusChanged = jniLookup< + static final _id_onWindowFocusChanged = _class.instanceMethodId( + r"onWindowFocusChanged", + r"(Z)V", + ); + + static final _onWindowFocusChanged = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__onWindowFocusChanged") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void onWindowFocusChanged(boolean z) void onWindowFocusChanged( bool z, ) { - _onWindowFocusChanged(reference.pointer, z ? 1 : 0).check(); + _onWindowFocusChanged(reference.pointer, + _id_onWindowFocusChanged as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _onAttachedToWindow = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onAttachedToWindow") - .asFunction)>(); + static final _id_onAttachedToWindow = _class.instanceMethodId( + r"onAttachedToWindow", + r"()V", + ); + + static final _onAttachedToWindow = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onAttachedToWindow() void onAttachedToWindow() { - _onAttachedToWindow(reference.pointer).check(); + _onAttachedToWindow( + reference.pointer, _id_onAttachedToWindow as jni.JMethodIDPtr) + .check(); } - static final _onDetachedFromWindow = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onDetachedFromWindow") - .asFunction)>(); + static final _id_onDetachedFromWindow = _class.instanceMethodId( + r"onDetachedFromWindow", + r"()V", + ); + + static final _onDetachedFromWindow = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onDetachedFromWindow() void onDetachedFromWindow() { - _onDetachedFromWindow(reference.pointer).check(); + _onDetachedFromWindow( + reference.pointer, _id_onDetachedFromWindow as jni.JMethodIDPtr) + .check(); } - static final _hasWindowFocus = jniLookup< - ffi - .NativeFunction)>>( - "Activity__hasWindowFocus") - .asFunction)>(); + static final _id_hasWindowFocus = _class.instanceMethodId( + r"hasWindowFocus", + r"()Z", + ); + + static final _hasWindowFocus = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean hasWindowFocus() bool hasWindowFocus() { - return _hasWindowFocus(reference.pointer).boolean; + return _hasWindowFocus( + reference.pointer, _id_hasWindowFocus as jni.JMethodIDPtr) + .boolean; } - static final _dispatchKeyEvent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__dispatchKeyEvent") + static final _id_dispatchKeyEvent = _class.instanceMethodId( + r"dispatchKeyEvent", + r"(Landroid/view/KeyEvent;)Z", + ); + + static final _dispatchKeyEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean dispatchKeyEvent(android.view.KeyEvent keyEvent) bool dispatchKeyEvent( jni.JObject keyEvent, ) { - return _dispatchKeyEvent(reference.pointer, keyEvent.reference.pointer) + return _dispatchKeyEvent( + reference.pointer, + _id_dispatchKeyEvent as jni.JMethodIDPtr, + keyEvent.reference.pointer) .boolean; } - static final _dispatchKeyShortcutEvent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__dispatchKeyShortcutEvent") + static final _id_dispatchKeyShortcutEvent = _class.instanceMethodId( + r"dispatchKeyShortcutEvent", + r"(Landroid/view/KeyEvent;)Z", + ); + + static final _dispatchKeyShortcutEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean dispatchKeyShortcutEvent(android.view.KeyEvent keyEvent) bool dispatchKeyShortcutEvent( jni.JObject keyEvent, ) { return _dispatchKeyShortcutEvent( - reference.pointer, keyEvent.reference.pointer) + reference.pointer, + _id_dispatchKeyShortcutEvent as jni.JMethodIDPtr, + keyEvent.reference.pointer) .boolean; } - static final _dispatchTouchEvent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__dispatchTouchEvent") + static final _id_dispatchTouchEvent = _class.instanceMethodId( + r"dispatchTouchEvent", + r"(Landroid/view/MotionEvent;)Z", + ); + + static final _dispatchTouchEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean dispatchTouchEvent(android.view.MotionEvent motionEvent) bool dispatchTouchEvent( jni.JObject motionEvent, ) { - return _dispatchTouchEvent(reference.pointer, motionEvent.reference.pointer) + return _dispatchTouchEvent( + reference.pointer, + _id_dispatchTouchEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) .boolean; } - static final _dispatchTrackballEvent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__dispatchTrackballEvent") + static final _id_dispatchTrackballEvent = _class.instanceMethodId( + r"dispatchTrackballEvent", + r"(Landroid/view/MotionEvent;)Z", + ); + + static final _dispatchTrackballEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean dispatchTrackballEvent(android.view.MotionEvent motionEvent) bool dispatchTrackballEvent( jni.JObject motionEvent, ) { return _dispatchTrackballEvent( - reference.pointer, motionEvent.reference.pointer) + reference.pointer, + _id_dispatchTrackballEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) .boolean; } - static final _dispatchGenericMotionEvent = jniLookup< + static final _id_dispatchGenericMotionEvent = _class.instanceMethodId( + r"dispatchGenericMotionEvent", + r"(Landroid/view/MotionEvent;)Z", + ); + + static final _dispatchGenericMotionEvent = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__dispatchGenericMotionEvent") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean dispatchGenericMotionEvent(android.view.MotionEvent motionEvent) bool dispatchGenericMotionEvent( jni.JObject motionEvent, ) { return _dispatchGenericMotionEvent( - reference.pointer, motionEvent.reference.pointer) + reference.pointer, + _id_dispatchGenericMotionEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) .boolean; } - static final _dispatchPopulateAccessibilityEvent = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__dispatchPopulateAccessibilityEvent") - .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + static final _id_dispatchPopulateAccessibilityEvent = _class.instanceMethodId( + r"dispatchPopulateAccessibilityEvent", + r"(Landroid/view/accessibility/AccessibilityEvent;)Z", + ); + + static final _dispatchPopulateAccessibilityEvent = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean dispatchPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent accessibilityEvent) bool dispatchPopulateAccessibilityEvent( jni.JObject accessibilityEvent, ) { return _dispatchPopulateAccessibilityEvent( - reference.pointer, accessibilityEvent.reference.pointer) + reference.pointer, + _id_dispatchPopulateAccessibilityEvent as jni.JMethodIDPtr, + accessibilityEvent.reference.pointer) .boolean; } - static final _onCreatePanelView = jniLookup< + static final _id_onCreatePanelView = _class.instanceMethodId( + r"onCreatePanelView", + r"(I)Landroid/view/View;", + ); + + static final _onCreatePanelView = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__onCreatePanelView") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public android.view.View onCreatePanelView(int i) /// The returned object must be released after use, by calling the [release] method. jni.JObject onCreatePanelView( int i, ) { - return _onCreatePanelView(reference.pointer, i) + return _onCreatePanelView( + reference.pointer, _id_onCreatePanelView as jni.JMethodIDPtr, i) .object(const jni.JObjectType()); } - static final _onCreatePanelMenu = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onCreatePanelMenu") + static final _id_onCreatePanelMenu = _class.instanceMethodId( + r"onCreatePanelMenu", + r"(ILandroid/view/Menu;)Z", + ); + + static final _onCreatePanelMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public boolean onCreatePanelMenu(int i, android.view.Menu menu) bool onCreatePanelMenu( int i, jni.JObject menu, ) { - return _onCreatePanelMenu(reference.pointer, i, menu.reference.pointer) + return _onCreatePanelMenu( + reference.pointer, + _id_onCreatePanelMenu as jni.JMethodIDPtr, + i, + menu.reference.pointer) .boolean; } - static final _onPreparePanel = jniLookup< + static final _id_onPreparePanel = _class.instanceMethodId( + r"onPreparePanel", + r"(ILandroid/view/View;Landroid/view/Menu;)Z", + ); + + static final _onPreparePanel = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer)>>("Activity__onPreparePanel") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, int, + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, ffi.Pointer, ffi.Pointer)>(); /// from: public boolean onPreparePanel(int i, android.view.View view, android.view.Menu menu) @@ -12393,229 +17624,399 @@ class Activity extends jni.JObject { jni.JObject view, jni.JObject menu, ) { - return _onPreparePanel(reference.pointer, i, view.reference.pointer, + return _onPreparePanel( + reference.pointer, + _id_onPreparePanel as jni.JMethodIDPtr, + i, + view.reference.pointer, menu.reference.pointer) .boolean; } - static final _onMenuOpened = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onMenuOpened") + static final _id_onMenuOpened = _class.instanceMethodId( + r"onMenuOpened", + r"(ILandroid/view/Menu;)Z", + ); + + static final _onMenuOpened = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public boolean onMenuOpened(int i, android.view.Menu menu) bool onMenuOpened( int i, jni.JObject menu, ) { - return _onMenuOpened(reference.pointer, i, menu.reference.pointer).boolean; + return _onMenuOpened(reference.pointer, + _id_onMenuOpened as jni.JMethodIDPtr, i, menu.reference.pointer) + .boolean; } - static final _onMenuItemSelected = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onMenuItemSelected") + static final _id_onMenuItemSelected = _class.instanceMethodId( + r"onMenuItemSelected", + r"(ILandroid/view/MenuItem;)Z", + ); + + static final _onMenuItemSelected = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public boolean onMenuItemSelected(int i, android.view.MenuItem menuItem) bool onMenuItemSelected( int i, jni.JObject menuItem, ) { - return _onMenuItemSelected(reference.pointer, i, menuItem.reference.pointer) + return _onMenuItemSelected( + reference.pointer, + _id_onMenuItemSelected as jni.JMethodIDPtr, + i, + menuItem.reference.pointer) .boolean; } - static final _onPanelClosed = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onPanelClosed") + static final _id_onPanelClosed = _class.instanceMethodId( + r"onPanelClosed", + r"(ILandroid/view/Menu;)V", + ); + + static final _onPanelClosed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: public void onPanelClosed(int i, android.view.Menu menu) void onPanelClosed( int i, jni.JObject menu, ) { - _onPanelClosed(reference.pointer, i, menu.reference.pointer).check(); + _onPanelClosed(reference.pointer, _id_onPanelClosed as jni.JMethodIDPtr, i, + menu.reference.pointer) + .check(); } - static final _invalidateOptionsMenu = jniLookup< - ffi - .NativeFunction)>>( - "Activity__invalidateOptionsMenu") - .asFunction)>(); + static final _id_invalidateOptionsMenu = _class.instanceMethodId( + r"invalidateOptionsMenu", + r"()V", + ); + + static final _invalidateOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void invalidateOptionsMenu() void invalidateOptionsMenu() { - _invalidateOptionsMenu(reference.pointer).check(); + _invalidateOptionsMenu( + reference.pointer, _id_invalidateOptionsMenu as jni.JMethodIDPtr) + .check(); } - static final _onCreateOptionsMenu = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onCreateOptionsMenu") + static final _id_onCreateOptionsMenu = _class.instanceMethodId( + r"onCreateOptionsMenu", + r"(Landroid/view/Menu;)Z", + ); + + static final _onCreateOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onCreateOptionsMenu(android.view.Menu menu) bool onCreateOptionsMenu( jni.JObject menu, ) { - return _onCreateOptionsMenu(reference.pointer, menu.reference.pointer) + return _onCreateOptionsMenu(reference.pointer, + _id_onCreateOptionsMenu as jni.JMethodIDPtr, menu.reference.pointer) .boolean; } - static final _onPrepareOptionsMenu = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onPrepareOptionsMenu") + static final _id_onPrepareOptionsMenu = _class.instanceMethodId( + r"onPrepareOptionsMenu", + r"(Landroid/view/Menu;)Z", + ); + + static final _onPrepareOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onPrepareOptionsMenu(android.view.Menu menu) bool onPrepareOptionsMenu( jni.JObject menu, ) { - return _onPrepareOptionsMenu(reference.pointer, menu.reference.pointer) + return _onPrepareOptionsMenu( + reference.pointer, + _id_onPrepareOptionsMenu as jni.JMethodIDPtr, + menu.reference.pointer) .boolean; } - static final _onOptionsItemSelected = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onOptionsItemSelected") + static final _id_onOptionsItemSelected = _class.instanceMethodId( + r"onOptionsItemSelected", + r"(Landroid/view/MenuItem;)Z", + ); + + static final _onOptionsItemSelected = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onOptionsItemSelected(android.view.MenuItem menuItem) bool onOptionsItemSelected( jni.JObject menuItem, ) { - return _onOptionsItemSelected(reference.pointer, menuItem.reference.pointer) + return _onOptionsItemSelected( + reference.pointer, + _id_onOptionsItemSelected as jni.JMethodIDPtr, + menuItem.reference.pointer) .boolean; } - static final _onNavigateUp = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onNavigateUp") - .asFunction)>(); + static final _id_onNavigateUp = _class.instanceMethodId( + r"onNavigateUp", + r"()Z", + ); + + static final _onNavigateUp = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean onNavigateUp() bool onNavigateUp() { - return _onNavigateUp(reference.pointer).boolean; + return _onNavigateUp( + reference.pointer, _id_onNavigateUp as jni.JMethodIDPtr) + .boolean; } - static final _onNavigateUpFromChild = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onNavigateUpFromChild") + static final _id_onNavigateUpFromChild = _class.instanceMethodId( + r"onNavigateUpFromChild", + r"(Landroid/app/Activity;)Z", + ); + + static final _onNavigateUpFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onNavigateUpFromChild(android.app.Activity activity) bool onNavigateUpFromChild( Activity activity, ) { - return _onNavigateUpFromChild(reference.pointer, activity.reference.pointer) + return _onNavigateUpFromChild( + reference.pointer, + _id_onNavigateUpFromChild as jni.JMethodIDPtr, + activity.reference.pointer) .boolean; } - static final _onCreateNavigateUpTaskStack = jniLookup< + static final _id_onCreateNavigateUpTaskStack = _class.instanceMethodId( + r"onCreateNavigateUpTaskStack", + r"(Landroid/app/TaskStackBuilder;)V", + ); + + static final _onCreateNavigateUpTaskStack = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__onCreateNavigateUpTaskStack") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onCreateNavigateUpTaskStack(android.app.TaskStackBuilder taskStackBuilder) void onCreateNavigateUpTaskStack( jni.JObject taskStackBuilder, ) { _onCreateNavigateUpTaskStack( - reference.pointer, taskStackBuilder.reference.pointer) + reference.pointer, + _id_onCreateNavigateUpTaskStack as jni.JMethodIDPtr, + taskStackBuilder.reference.pointer) .check(); } - static final _onPrepareNavigateUpTaskStack = jniLookup< + static final _id_onPrepareNavigateUpTaskStack = _class.instanceMethodId( + r"onPrepareNavigateUpTaskStack", + r"(Landroid/app/TaskStackBuilder;)V", + ); + + static final _onPrepareNavigateUpTaskStack = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__onPrepareNavigateUpTaskStack") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onPrepareNavigateUpTaskStack(android.app.TaskStackBuilder taskStackBuilder) void onPrepareNavigateUpTaskStack( jni.JObject taskStackBuilder, ) { _onPrepareNavigateUpTaskStack( - reference.pointer, taskStackBuilder.reference.pointer) + reference.pointer, + _id_onPrepareNavigateUpTaskStack as jni.JMethodIDPtr, + taskStackBuilder.reference.pointer) .check(); } - static final _onOptionsMenuClosed = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onOptionsMenuClosed") + static final _id_onOptionsMenuClosed = _class.instanceMethodId( + r"onOptionsMenuClosed", + r"(Landroid/view/Menu;)V", + ); + + static final _onOptionsMenuClosed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onOptionsMenuClosed(android.view.Menu menu) void onOptionsMenuClosed( jni.JObject menu, ) { - _onOptionsMenuClosed(reference.pointer, menu.reference.pointer).check(); + _onOptionsMenuClosed(reference.pointer, + _id_onOptionsMenuClosed as jni.JMethodIDPtr, menu.reference.pointer) + .check(); } - static final _openOptionsMenu = jniLookup< - ffi - .NativeFunction)>>( - "Activity__openOptionsMenu") - .asFunction)>(); + static final _id_openOptionsMenu = _class.instanceMethodId( + r"openOptionsMenu", + r"()V", + ); + + static final _openOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void openOptionsMenu() void openOptionsMenu() { - _openOptionsMenu(reference.pointer).check(); + _openOptionsMenu(reference.pointer, _id_openOptionsMenu as jni.JMethodIDPtr) + .check(); } - static final _closeOptionsMenu = jniLookup< - ffi - .NativeFunction)>>( - "Activity__closeOptionsMenu") - .asFunction)>(); + static final _id_closeOptionsMenu = _class.instanceMethodId( + r"closeOptionsMenu", + r"()V", + ); + + static final _closeOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void closeOptionsMenu() void closeOptionsMenu() { - _closeOptionsMenu(reference.pointer).check(); + _closeOptionsMenu( + reference.pointer, _id_closeOptionsMenu as jni.JMethodIDPtr) + .check(); } - static final _onCreateContextMenu = jniLookup< + static final _id_onCreateContextMenu = _class.instanceMethodId( + r"onCreateContextMenu", + r"(Landroid/view/ContextMenu;Landroid/view/View;Landroid/view/ContextMenu$ContextMenuInfo;)V", + ); + + static final _onCreateContextMenu = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__onCreateContextMenu") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public void onCreateContextMenu(android.view.ContextMenu contextMenu, android.view.View view, android.view.ContextMenu$ContextMenuInfo contextMenuInfo) void onCreateContextMenu( @@ -12623,121 +18024,208 @@ class Activity extends jni.JObject { jni.JObject view, jni.JObject contextMenuInfo, ) { - _onCreateContextMenu(reference.pointer, contextMenu.reference.pointer, - view.reference.pointer, contextMenuInfo.reference.pointer) + _onCreateContextMenu( + reference.pointer, + _id_onCreateContextMenu as jni.JMethodIDPtr, + contextMenu.reference.pointer, + view.reference.pointer, + contextMenuInfo.reference.pointer) .check(); } - static final _registerForContextMenu = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__registerForContextMenu") + static final _id_registerForContextMenu = _class.instanceMethodId( + r"registerForContextMenu", + r"(Landroid/view/View;)V", + ); + + static final _registerForContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void registerForContextMenu(android.view.View view) void registerForContextMenu( jni.JObject view, ) { - _registerForContextMenu(reference.pointer, view.reference.pointer).check(); + _registerForContextMenu( + reference.pointer, + _id_registerForContextMenu as jni.JMethodIDPtr, + view.reference.pointer) + .check(); } - static final _unregisterForContextMenu = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__unregisterForContextMenu") + static final _id_unregisterForContextMenu = _class.instanceMethodId( + r"unregisterForContextMenu", + r"(Landroid/view/View;)V", + ); + + static final _unregisterForContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void unregisterForContextMenu(android.view.View view) void unregisterForContextMenu( jni.JObject view, ) { - _unregisterForContextMenu(reference.pointer, view.reference.pointer) + _unregisterForContextMenu( + reference.pointer, + _id_unregisterForContextMenu as jni.JMethodIDPtr, + view.reference.pointer) .check(); } - static final _openContextMenu = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__openContextMenu") + static final _id_openContextMenu = _class.instanceMethodId( + r"openContextMenu", + r"(Landroid/view/View;)V", + ); + + static final _openContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void openContextMenu(android.view.View view) void openContextMenu( jni.JObject view, ) { - _openContextMenu(reference.pointer, view.reference.pointer).check(); + _openContextMenu(reference.pointer, _id_openContextMenu as jni.JMethodIDPtr, + view.reference.pointer) + .check(); } - static final _closeContextMenu = jniLookup< - ffi - .NativeFunction)>>( - "Activity__closeContextMenu") - .asFunction)>(); + static final _id_closeContextMenu = _class.instanceMethodId( + r"closeContextMenu", + r"()V", + ); + + static final _closeContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void closeContextMenu() void closeContextMenu() { - _closeContextMenu(reference.pointer).check(); + _closeContextMenu( + reference.pointer, _id_closeContextMenu as jni.JMethodIDPtr) + .check(); } - static final _onContextItemSelected = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onContextItemSelected") + static final _id_onContextItemSelected = _class.instanceMethodId( + r"onContextItemSelected", + r"(Landroid/view/MenuItem;)Z", + ); + + static final _onContextItemSelected = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onContextItemSelected(android.view.MenuItem menuItem) bool onContextItemSelected( jni.JObject menuItem, ) { - return _onContextItemSelected(reference.pointer, menuItem.reference.pointer) + return _onContextItemSelected( + reference.pointer, + _id_onContextItemSelected as jni.JMethodIDPtr, + menuItem.reference.pointer) .boolean; } - static final _onContextMenuClosed = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onContextMenuClosed") + static final _id_onContextMenuClosed = _class.instanceMethodId( + r"onContextMenuClosed", + r"(Landroid/view/Menu;)V", + ); + + static final _onContextMenuClosed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onContextMenuClosed(android.view.Menu menu) void onContextMenuClosed( jni.JObject menu, ) { - _onContextMenuClosed(reference.pointer, menu.reference.pointer).check(); + _onContextMenuClosed(reference.pointer, + _id_onContextMenuClosed as jni.JMethodIDPtr, menu.reference.pointer) + .check(); } - static final _onCreateDialog = jniLookup< + static final _id_onCreateDialog = _class.instanceMethodId( + r"onCreateDialog", + r"(I)Landroid/app/Dialog;", + ); + + static final _onCreateDialog = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__onCreateDialog") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: protected android.app.Dialog onCreateDialog(int i) /// The returned object must be released after use, by calling the [release] method. jni.JObject onCreateDialog( int i, ) { - return _onCreateDialog(reference.pointer, i) + return _onCreateDialog( + reference.pointer, _id_onCreateDialog as jni.JMethodIDPtr, i) .object(const jni.JObjectType()); } - static final _onCreateDialog1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onCreateDialog1") + static final _id_onCreateDialog1 = _class.instanceMethodId( + r"onCreateDialog", + r"(ILandroid/os/Bundle;)Landroid/app/Dialog;", + ); + + static final _onCreateDialog1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: protected android.app.Dialog onCreateDialog(int i, android.os.Bundle bundle) /// The returned object must be released after use, by calling the [release] method. @@ -12745,36 +18233,59 @@ class Activity extends jni.JObject { int i, jni.JObject bundle, ) { - return _onCreateDialog1(reference.pointer, i, bundle.reference.pointer) + return _onCreateDialog1( + reference.pointer, + _id_onCreateDialog1 as jni.JMethodIDPtr, + i, + bundle.reference.pointer) .object(const jni.JObjectType()); } - static final _onPrepareDialog = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onPrepareDialog") + static final _id_onPrepareDialog = _class.instanceMethodId( + r"onPrepareDialog", + r"(ILandroid/app/Dialog;)V", + ); + + static final _onPrepareDialog = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: protected void onPrepareDialog(int i, android.app.Dialog dialog) void onPrepareDialog( int i, jni.JObject dialog, ) { - _onPrepareDialog(reference.pointer, i, dialog.reference.pointer).check(); + _onPrepareDialog(reference.pointer, _id_onPrepareDialog as jni.JMethodIDPtr, + i, dialog.reference.pointer) + .check(); } - static final _onPrepareDialog1 = jniLookup< + static final _id_onPrepareDialog1 = _class.instanceMethodId( + r"onPrepareDialog", + r"(ILandroid/app/Dialog;Landroid/os/Bundle;)V", + ); + + static final _onPrepareDialog1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Pointer)>>("Activity__onPrepareDialog1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, int, - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer, ffi.Pointer)>(); /// from: protected void onPrepareDialog(int i, android.app.Dialog dialog, android.os.Bundle bundle) void onPrepareDialog1( @@ -12782,116 +18293,206 @@ class Activity extends jni.JObject { jni.JObject dialog, jni.JObject bundle, ) { - _onPrepareDialog1(reference.pointer, i, dialog.reference.pointer, + _onPrepareDialog1( + reference.pointer, + _id_onPrepareDialog1 as jni.JMethodIDPtr, + i, + dialog.reference.pointer, bundle.reference.pointer) .check(); } - static final _showDialog = jniLookup< + static final _id_showDialog = _class.instanceMethodId( + r"showDialog", + r"(I)V", + ); + + static final _showDialog = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__showDialog") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void showDialog(int i) void showDialog( int i, ) { - _showDialog(reference.pointer, i).check(); + _showDialog(reference.pointer, _id_showDialog as jni.JMethodIDPtr, i) + .check(); } - static final _showDialog1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__showDialog1") + static final _id_showDialog1 = _class.instanceMethodId( + r"showDialog", + r"(ILandroid/os/Bundle;)Z", + ); + + static final _showDialog1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public final boolean showDialog(int i, android.os.Bundle bundle) bool showDialog1( int i, jni.JObject bundle, ) { - return _showDialog1(reference.pointer, i, bundle.reference.pointer).boolean; + return _showDialog1(reference.pointer, _id_showDialog1 as jni.JMethodIDPtr, + i, bundle.reference.pointer) + .boolean; } - static final _dismissDialog = jniLookup< + static final _id_dismissDialog = _class.instanceMethodId( + r"dismissDialog", + r"(I)V", + ); + + static final _dismissDialog = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__dismissDialog") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void dismissDialog(int i) void dismissDialog( int i, ) { - _dismissDialog(reference.pointer, i).check(); + _dismissDialog(reference.pointer, _id_dismissDialog as jni.JMethodIDPtr, i) + .check(); } - static final _removeDialog = jniLookup< + static final _id_removeDialog = _class.instanceMethodId( + r"removeDialog", + r"(I)V", + ); + + static final _removeDialog = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__removeDialog") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void removeDialog(int i) void removeDialog( int i, ) { - _removeDialog(reference.pointer, i).check(); + _removeDialog(reference.pointer, _id_removeDialog as jni.JMethodIDPtr, i) + .check(); } - static final _onSearchRequested = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onSearchRequested") + static final _id_onSearchRequested = _class.instanceMethodId( + r"onSearchRequested", + r"(Landroid/view/SearchEvent;)Z", + ); + + static final _onSearchRequested = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean onSearchRequested(android.view.SearchEvent searchEvent) bool onSearchRequested( jni.JObject searchEvent, ) { - return _onSearchRequested(reference.pointer, searchEvent.reference.pointer) + return _onSearchRequested( + reference.pointer, + _id_onSearchRequested as jni.JMethodIDPtr, + searchEvent.reference.pointer) .boolean; } - static final _onSearchRequested1 = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onSearchRequested1") - .asFunction)>(); + static final _id_onSearchRequested1 = _class.instanceMethodId( + r"onSearchRequested", + r"()Z", + ); + + static final _onSearchRequested1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean onSearchRequested() bool onSearchRequested1() { - return _onSearchRequested1(reference.pointer).boolean; + return _onSearchRequested1( + reference.pointer, _id_onSearchRequested1 as jni.JMethodIDPtr) + .boolean; } - static final _getSearchEvent = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getSearchEvent") - .asFunction)>(); + static final _id_getSearchEvent = _class.instanceMethodId( + r"getSearchEvent", + r"()Landroid/view/SearchEvent;", + ); + + static final _getSearchEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final android.view.SearchEvent getSearchEvent() /// The returned object must be released after use, by calling the [release] method. jni.JObject getSearchEvent() { - return _getSearchEvent(reference.pointer).object(const jni.JObjectType()); + return _getSearchEvent( + reference.pointer, _id_getSearchEvent as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _startSearch = jniLookup< + static final _id_startSearch = _class.instanceMethodId( + r"startSearch", + r"(Ljava/lang/String;ZLandroid/os/Bundle;Z)V", + ); + + static final _startSearch = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Uint8, - ffi.Pointer, - ffi.Uint8)>>("Activity__startSearch") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer, int)>(); /// from: public void startSearch(java.lang.String string, boolean z, android.os.Bundle bundle, boolean z1) void startSearch( @@ -12900,166 +18501,288 @@ class Activity extends jni.JObject { jni.JObject bundle, bool z1, ) { - _startSearch(reference.pointer, string.reference.pointer, z ? 1 : 0, - bundle.reference.pointer, z1 ? 1 : 0) + _startSearch( + reference.pointer, + _id_startSearch as jni.JMethodIDPtr, + string.reference.pointer, + z ? 1 : 0, + bundle.reference.pointer, + z1 ? 1 : 0) .check(); } - static final _triggerSearch = jniLookup< + static final _id_triggerSearch = _class.instanceMethodId( + r"triggerSearch", + r"(Ljava/lang/String;Landroid/os/Bundle;)V", + ); + + static final _triggerSearch = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__triggerSearch") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void triggerSearch(java.lang.String string, android.os.Bundle bundle) void triggerSearch( jni.JString string, jni.JObject bundle, ) { - _triggerSearch(reference.pointer, string.reference.pointer, - bundle.reference.pointer) + _triggerSearch(reference.pointer, _id_triggerSearch as jni.JMethodIDPtr, + string.reference.pointer, bundle.reference.pointer) .check(); } - static final _takeKeyEvents = jniLookup< + static final _id_takeKeyEvents = _class.instanceMethodId( + r"takeKeyEvents", + r"(Z)V", + ); + + static final _takeKeyEvents = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Uint8)>>("Activity__takeKeyEvents") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void takeKeyEvents(boolean z) void takeKeyEvents( bool z, ) { - _takeKeyEvents(reference.pointer, z ? 1 : 0).check(); + _takeKeyEvents( + reference.pointer, _id_takeKeyEvents as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _requestWindowFeature = jniLookup< + static final _id_requestWindowFeature = _class.instanceMethodId( + r"requestWindowFeature", + r"(I)Z", + ); + + static final _requestWindowFeature = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__requestWindowFeature") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final boolean requestWindowFeature(int i) bool requestWindowFeature( int i, ) { - return _requestWindowFeature(reference.pointer, i).boolean; + return _requestWindowFeature( + reference.pointer, _id_requestWindowFeature as jni.JMethodIDPtr, i) + .boolean; } - static final _setFeatureDrawableResource = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Int32)>>("Activity__setFeatureDrawableResource") - .asFunction, int, int)>(); + static final _id_setFeatureDrawableResource = _class.instanceMethodId( + r"setFeatureDrawableResource", + r"(II)V", + ); + + static final _setFeatureDrawableResource = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.VarArgs<(ffi.Int64, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int)>(); /// from: public final void setFeatureDrawableResource(int i, int i1) void setFeatureDrawableResource( int i, int i1, ) { - _setFeatureDrawableResource(reference.pointer, i, i1).check(); + _setFeatureDrawableResource(reference.pointer, + _id_setFeatureDrawableResource as jni.JMethodIDPtr, i, i1) + .check(); } - static final _setFeatureDrawableUri = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__setFeatureDrawableUri") + static final _id_setFeatureDrawableUri = _class.instanceMethodId( + r"setFeatureDrawableUri", + r"(ILandroid/net/Uri;)V", + ); + + static final _setFeatureDrawableUri = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: public final void setFeatureDrawableUri(int i, android.net.Uri uri) void setFeatureDrawableUri( int i, jni.JObject uri, ) { - _setFeatureDrawableUri(reference.pointer, i, uri.reference.pointer).check(); + _setFeatureDrawableUri( + reference.pointer, + _id_setFeatureDrawableUri as jni.JMethodIDPtr, + i, + uri.reference.pointer) + .check(); } - static final _setFeatureDrawable = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__setFeatureDrawable") + static final _id_setFeatureDrawable = _class.instanceMethodId( + r"setFeatureDrawable", + r"(ILandroid/graphics/drawable/Drawable;)V", + ); + + static final _setFeatureDrawable = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: public final void setFeatureDrawable(int i, android.graphics.drawable.Drawable drawable) void setFeatureDrawable( int i, jni.JObject drawable, ) { - _setFeatureDrawable(reference.pointer, i, drawable.reference.pointer) + _setFeatureDrawable( + reference.pointer, + _id_setFeatureDrawable as jni.JMethodIDPtr, + i, + drawable.reference.pointer) .check(); } - static final _setFeatureDrawableAlpha = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Int32)>>("Activity__setFeatureDrawableAlpha") - .asFunction, int, int)>(); + static final _id_setFeatureDrawableAlpha = _class.instanceMethodId( + r"setFeatureDrawableAlpha", + r"(II)V", + ); + + static final _setFeatureDrawableAlpha = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.VarArgs<(ffi.Int64, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int)>(); /// from: public final void setFeatureDrawableAlpha(int i, int i1) void setFeatureDrawableAlpha( int i, int i1, ) { - _setFeatureDrawableAlpha(reference.pointer, i, i1).check(); + _setFeatureDrawableAlpha(reference.pointer, + _id_setFeatureDrawableAlpha as jni.JMethodIDPtr, i, i1) + .check(); } - static final _getLayoutInflater = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getLayoutInflater") - .asFunction)>(); + static final _id_getLayoutInflater = _class.instanceMethodId( + r"getLayoutInflater", + r"()Landroid/view/LayoutInflater;", + ); + + static final _getLayoutInflater = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.view.LayoutInflater getLayoutInflater() /// The returned object must be released after use, by calling the [release] method. jni.JObject getLayoutInflater() { - return _getLayoutInflater(reference.pointer) + return _getLayoutInflater( + reference.pointer, _id_getLayoutInflater as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getMenuInflater = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getMenuInflater") - .asFunction)>(); + static final _id_getMenuInflater = _class.instanceMethodId( + r"getMenuInflater", + r"()Landroid/view/MenuInflater;", + ); + + static final _getMenuInflater = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.view.MenuInflater getMenuInflater() /// The returned object must be released after use, by calling the [release] method. jni.JObject getMenuInflater() { - return _getMenuInflater(reference.pointer).object(const jni.JObjectType()); + return _getMenuInflater( + reference.pointer, _id_getMenuInflater as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _setTheme = jniLookup< + static final _id_setTheme = _class.instanceMethodId( + r"setTheme", + r"(I)V", + ); + + static final _setTheme = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__setTheme") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setTheme(int i) void setTheme( int i, ) { - _setTheme(reference.pointer, i).check(); + _setTheme(reference.pointer, _id_setTheme as jni.JMethodIDPtr, i).check(); } - static final _onApplyThemeResource = jniLookup< + static final _id_onApplyThemeResource = _class.instanceMethodId( + r"onApplyThemeResource", + r"(Landroid/content/res/Resources$Theme;IZ)V", + ); + + static final _onApplyThemeResource = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Uint8)>>("Activity__onApplyThemeResource") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int)>(); /// from: protected void onApplyThemeResource(android.content.res.Resources$Theme theme, int i, boolean z) void onApplyThemeResource( @@ -13068,37 +18791,62 @@ class Activity extends jni.JObject { bool z, ) { _onApplyThemeResource( - reference.pointer, theme.reference.pointer, i, z ? 1 : 0) + reference.pointer, + _id_onApplyThemeResource as jni.JMethodIDPtr, + theme.reference.pointer, + i, + z ? 1 : 0) .check(); } - static final _requestPermissions = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__requestPermissions") + static final _id_requestPermissions = _class.instanceMethodId( + r"requestPermissions", + r"([Ljava/lang/String;I)V", + ); + + static final _requestPermissions = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public final void requestPermissions(java.lang.String[] strings, int i) void requestPermissions( jni.JArray strings, int i, ) { - _requestPermissions(reference.pointer, strings.reference.pointer, i) + _requestPermissions( + reference.pointer, + _id_requestPermissions as jni.JMethodIDPtr, + strings.reference.pointer, + i) .check(); } - static final _onRequestPermissionsResult = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer, ffi.Pointer)>>( - "Activity__onRequestPermissionsResult") + static final _id_onRequestPermissionsResult = _class.instanceMethodId( + r"onRequestPermissionsResult", + r"(I[Ljava/lang/String;[I)V", + ); + + static final _onRequestPermissionsResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Int64, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, int, - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer, ffi.Pointer)>(); /// from: public void onRequestPermissionsResult(int i, java.lang.String[] strings, int[] is) void onRequestPermissionsResult( @@ -13106,58 +18854,92 @@ class Activity extends jni.JObject { jni.JArray strings, jni.JArray is0, ) { - _onRequestPermissionsResult(reference.pointer, i, strings.reference.pointer, + _onRequestPermissionsResult( + reference.pointer, + _id_onRequestPermissionsResult as jni.JMethodIDPtr, + i, + strings.reference.pointer, is0.reference.pointer) .check(); } - static final _shouldShowRequestPermissionRationale = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__shouldShowRequestPermissionRationale") - .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + static final _id_shouldShowRequestPermissionRationale = + _class.instanceMethodId( + r"shouldShowRequestPermissionRationale", + r"(Ljava/lang/String;)Z", + ); + + static final _shouldShowRequestPermissionRationale = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean shouldShowRequestPermissionRationale(java.lang.String string) bool shouldShowRequestPermissionRationale( jni.JString string, ) { return _shouldShowRequestPermissionRationale( - reference.pointer, string.reference.pointer) + reference.pointer, + _id_shouldShowRequestPermissionRationale as jni.JMethodIDPtr, + string.reference.pointer) .boolean; } - static final _startActivityForResult = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__startActivityForResult") + static final _id_startActivityForResult = _class.instanceMethodId( + r"startActivityForResult", + r"(Landroid/content/Intent;I)V", + ); + + static final _startActivityForResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public void startActivityForResult(android.content.Intent intent, int i) void startActivityForResult( Intent intent, int i, ) { - _startActivityForResult(reference.pointer, intent.reference.pointer, i) + _startActivityForResult( + reference.pointer, + _id_startActivityForResult as jni.JMethodIDPtr, + intent.reference.pointer, + i) .check(); } - static final _startActivityForResult1 = jniLookup< + static final _id_startActivityForResult1 = _class.instanceMethodId( + r"startActivityForResult", + r"(Landroid/content/Intent;ILandroid/os/Bundle;)V", + ); + + static final _startActivityForResult1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("Activity__startActivityForResult1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); /// from: public void startActivityForResult(android.content.Intent intent, int i, android.os.Bundle bundle) void startActivityForResult1( @@ -13165,35 +18947,68 @@ class Activity extends jni.JObject { int i, jni.JObject bundle, ) { - _startActivityForResult1(reference.pointer, intent.reference.pointer, i, + _startActivityForResult1( + reference.pointer, + _id_startActivityForResult1 as jni.JMethodIDPtr, + intent.reference.pointer, + i, bundle.reference.pointer) .check(); } - static final _isActivityTransitionRunning = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isActivityTransitionRunning") - .asFunction)>(); + static final _id_isActivityTransitionRunning = _class.instanceMethodId( + r"isActivityTransitionRunning", + r"()Z", + ); + + static final _isActivityTransitionRunning = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isActivityTransitionRunning() bool isActivityTransitionRunning() { - return _isActivityTransitionRunning(reference.pointer).boolean; + return _isActivityTransitionRunning(reference.pointer, + _id_isActivityTransitionRunning as jni.JMethodIDPtr) + .boolean; } - static final _startIntentSenderForResult = jniLookup< + static final _id_startIntentSenderForResult = _class.instanceMethodId( + r"startIntentSenderForResult", + r"(Landroid/content/IntentSender;ILandroid/content/Intent;III)V", + ); + + static final _startIntentSenderForResult = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32)>>("Activity__startIntentSenderForResult") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer, int, int, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer, + int, + int, + int)>(); /// from: public void startIntentSenderForResult(android.content.IntentSender intentSender, int i, android.content.Intent intent, int i1, int i2, int i3) void startIntentSenderForResult( @@ -13206,6 +19021,7 @@ class Activity extends jni.JObject { ) { _startIntentSenderForResult( reference.pointer, + _id_startIntentSenderForResult as jni.JMethodIDPtr, intentSender.reference.pointer, i, intent.reference.pointer, @@ -13215,21 +19031,30 @@ class Activity extends jni.JObject { .check(); } - static final _startIntentSenderForResult1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32, - ffi.Pointer)>>( - "Activity__startIntentSenderForResult1") + static final _id_startIntentSenderForResult1 = _class.instanceMethodId( + r"startIntentSenderForResult", + r"(Landroid/content/IntentSender;ILandroid/content/Intent;IIILandroid/os/Bundle;)V", + ); + + static final _startIntentSenderForResult1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, int, ffi.Pointer, @@ -13250,6 +19075,7 @@ class Activity extends jni.JObject { ) { _startIntentSenderForResult1( reference.pointer, + _id_startIntentSenderForResult1 as jni.JMethodIDPtr, intentSender.reference.pointer, i, intent.reference.pointer, @@ -13260,88 +19086,138 @@ class Activity extends jni.JObject { .check(); } - static final _startActivity = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__startActivity") + static final _id_startActivity = _class.instanceMethodId( + r"startActivity", + r"(Landroid/content/Intent;)V", + ); + + static final _startActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void startActivity(android.content.Intent intent) void startActivity( Intent intent, ) { - _startActivity(reference.pointer, intent.reference.pointer).check(); + _startActivity(reference.pointer, _id_startActivity as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); } - static final _startActivity1 = jniLookup< + static final _id_startActivity1 = _class.instanceMethodId( + r"startActivity", + r"(Landroid/content/Intent;Landroid/os/Bundle;)V", + ); + + static final _startActivity1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__startActivity1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void startActivity(android.content.Intent intent, android.os.Bundle bundle) void startActivity1( Intent intent, jni.JObject bundle, ) { - _startActivity1(reference.pointer, intent.reference.pointer, - bundle.reference.pointer) + _startActivity1(reference.pointer, _id_startActivity1 as jni.JMethodIDPtr, + intent.reference.pointer, bundle.reference.pointer) .check(); } - static final _startActivities = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__startActivities") + static final _id_startActivities = _class.instanceMethodId( + r"startActivities", + r"([Landroid/content/Intent;)V", + ); + + static final _startActivities = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void startActivities(android.content.Intent[] intents) void startActivities( jni.JArray intents, ) { - _startActivities(reference.pointer, intents.reference.pointer).check(); + _startActivities(reference.pointer, _id_startActivities as jni.JMethodIDPtr, + intents.reference.pointer) + .check(); } - static final _startActivities1 = jniLookup< + static final _id_startActivities1 = _class.instanceMethodId( + r"startActivities", + r"([Landroid/content/Intent;Landroid/os/Bundle;)V", + ); + + static final _startActivities1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__startActivities1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public void startActivities(android.content.Intent[] intents, android.os.Bundle bundle) void startActivities1( jni.JArray intents, jni.JObject bundle, ) { - _startActivities1(reference.pointer, intents.reference.pointer, + _startActivities1( + reference.pointer, + _id_startActivities1 as jni.JMethodIDPtr, + intents.reference.pointer, bundle.reference.pointer) .check(); } - static final _startIntentSender = jniLookup< + static final _id_startIntentSender = _class.instanceMethodId( + r"startIntentSender", + r"(Landroid/content/IntentSender;Landroid/content/Intent;III)V", + ); + + static final _startIntentSender = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32)>>("Activity__startIntentSender") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, int, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int, int, int)>(); /// from: public void startIntentSender(android.content.IntentSender intentSender, android.content.Intent intent, int i, int i1, int i2) void startIntentSender( @@ -13351,24 +19227,46 @@ class Activity extends jni.JObject { int i1, int i2, ) { - _startIntentSender(reference.pointer, intentSender.reference.pointer, - intent.reference.pointer, i, i1, i2) + _startIntentSender( + reference.pointer, + _id_startIntentSender as jni.JMethodIDPtr, + intentSender.reference.pointer, + intent.reference.pointer, + i, + i1, + i2) .check(); } - static final _startIntentSender1 = jniLookup< + static final _id_startIntentSender1 = _class.instanceMethodId( + r"startIntentSender", + r"(Landroid/content/IntentSender;Landroid/content/Intent;IIILandroid/os/Bundle;)V", + ); + + static final _startIntentSender1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32, - ffi.Pointer)>>("Activity__startIntentSender1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, int, int, ffi.Pointer)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); /// from: public void startIntentSender(android.content.IntentSender intentSender, android.content.Intent intent, int i, int i1, int i2, android.os.Bundle bundle) void startIntentSender1( @@ -13379,20 +19277,33 @@ class Activity extends jni.JObject { int i2, jni.JObject bundle, ) { - _startIntentSender1(reference.pointer, intentSender.reference.pointer, - intent.reference.pointer, i, i1, i2, bundle.reference.pointer) + _startIntentSender1( + reference.pointer, + _id_startIntentSender1 as jni.JMethodIDPtr, + intentSender.reference.pointer, + intent.reference.pointer, + i, + i1, + i2, + bundle.reference.pointer) .check(); } - static final _startActivityIfNeeded = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__startActivityIfNeeded") + static final _id_startActivityIfNeeded = _class.instanceMethodId( + r"startActivityIfNeeded", + r"(Landroid/content/Intent;I)Z", + ); + + static final _startActivityIfNeeded = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public boolean startActivityIfNeeded(android.content.Intent intent, int i) bool startActivityIfNeeded( @@ -13400,20 +19311,32 @@ class Activity extends jni.JObject { int i, ) { return _startActivityIfNeeded( - reference.pointer, intent.reference.pointer, i) + reference.pointer, + _id_startActivityIfNeeded as jni.JMethodIDPtr, + intent.reference.pointer, + i) .boolean; } - static final _startActivityIfNeeded1 = jniLookup< + static final _id_startActivityIfNeeded1 = _class.instanceMethodId( + r"startActivityIfNeeded", + r"(Landroid/content/Intent;ILandroid/os/Bundle;)Z", + ); + + static final _startActivityIfNeeded1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("Activity__startActivityIfNeeded1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); /// from: public boolean startActivityIfNeeded(android.content.Intent intent, int i, android.os.Bundle bundle) bool startActivityIfNeeded1( @@ -13421,58 +19344,93 @@ class Activity extends jni.JObject { int i, jni.JObject bundle, ) { - return _startActivityIfNeeded1(reference.pointer, intent.reference.pointer, - i, bundle.reference.pointer) + return _startActivityIfNeeded1( + reference.pointer, + _id_startActivityIfNeeded1 as jni.JMethodIDPtr, + intent.reference.pointer, + i, + bundle.reference.pointer) .boolean; } - static final _startNextMatchingActivity = jniLookup< + static final _id_startNextMatchingActivity = _class.instanceMethodId( + r"startNextMatchingActivity", + r"(Landroid/content/Intent;)Z", + ); + + static final _startNextMatchingActivity = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__startNextMatchingActivity") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean startNextMatchingActivity(android.content.Intent intent) bool startNextMatchingActivity( Intent intent, ) { return _startNextMatchingActivity( - reference.pointer, intent.reference.pointer) + reference.pointer, + _id_startNextMatchingActivity as jni.JMethodIDPtr, + intent.reference.pointer) .boolean; } - static final _startNextMatchingActivity1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - "Activity__startNextMatchingActivity1") + static final _id_startNextMatchingActivity1 = _class.instanceMethodId( + r"startNextMatchingActivity", + r"(Landroid/content/Intent;Landroid/os/Bundle;)Z", + ); + + static final _startNextMatchingActivity1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public boolean startNextMatchingActivity(android.content.Intent intent, android.os.Bundle bundle) bool startNextMatchingActivity1( Intent intent, jni.JObject bundle, ) { - return _startNextMatchingActivity1(reference.pointer, - intent.reference.pointer, bundle.reference.pointer) + return _startNextMatchingActivity1( + reference.pointer, + _id_startNextMatchingActivity1 as jni.JMethodIDPtr, + intent.reference.pointer, + bundle.reference.pointer) .boolean; } - static final _startActivityFromChild = jniLookup< + static final _id_startActivityFromChild = _class.instanceMethodId( + r"startActivityFromChild", + r"(Landroid/app/Activity;Landroid/content/Intent;I)V", + ); + + static final _startActivityFromChild = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__startActivityFromChild") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); /// from: public void startActivityFromChild(android.app.Activity activity, android.content.Intent intent, int i) void startActivityFromChild( @@ -13480,22 +19438,40 @@ class Activity extends jni.JObject { Intent intent, int i, ) { - _startActivityFromChild(reference.pointer, activity.reference.pointer, - intent.reference.pointer, i) + _startActivityFromChild( + reference.pointer, + _id_startActivityFromChild as jni.JMethodIDPtr, + activity.reference.pointer, + intent.reference.pointer, + i) .check(); } - static final _startActivityFromChild1 = jniLookup< + static final _id_startActivityFromChild1 = _class.instanceMethodId( + r"startActivityFromChild", + r"(Landroid/app/Activity;Landroid/content/Intent;ILandroid/os/Bundle;)V", + ); + + static final _startActivityFromChild1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("Activity__startActivityFromChild1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); /// from: public void startActivityFromChild(android.app.Activity activity, android.content.Intent intent, int i, android.os.Bundle bundle) void startActivityFromChild1( @@ -13504,21 +19480,35 @@ class Activity extends jni.JObject { int i, jni.JObject bundle, ) { - _startActivityFromChild1(reference.pointer, activity.reference.pointer, - intent.reference.pointer, i, bundle.reference.pointer) + _startActivityFromChild1( + reference.pointer, + _id_startActivityFromChild1 as jni.JMethodIDPtr, + activity.reference.pointer, + intent.reference.pointer, + i, + bundle.reference.pointer) .check(); } - static final _startActivityFromFragment = jniLookup< + static final _id_startActivityFromFragment = _class.instanceMethodId( + r"startActivityFromFragment", + r"(Landroid/app/Fragment;Landroid/content/Intent;I)V", + ); + + static final _startActivityFromFragment = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__startActivityFromFragment") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); /// from: public void startActivityFromFragment(android.app.Fragment fragment, android.content.Intent intent, int i) void startActivityFromFragment( @@ -13526,23 +19516,40 @@ class Activity extends jni.JObject { Intent intent, int i, ) { - _startActivityFromFragment(reference.pointer, fragment.reference.pointer, - intent.reference.pointer, i) + _startActivityFromFragment( + reference.pointer, + _id_startActivityFromFragment as jni.JMethodIDPtr, + fragment.reference.pointer, + intent.reference.pointer, + i) .check(); } - static final _startActivityFromFragment1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>( - "Activity__startActivityFromFragment1") + static final _id_startActivityFromFragment1 = _class.instanceMethodId( + r"startActivityFromFragment", + r"(Landroid/app/Fragment;Landroid/content/Intent;ILandroid/os/Bundle;)V", + ); + + static final _startActivityFromFragment1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); /// from: public void startActivityFromFragment(android.app.Fragment fragment, android.content.Intent intent, int i, android.os.Bundle bundle) void startActivityFromFragment1( @@ -13551,25 +19558,40 @@ class Activity extends jni.JObject { int i, jni.JObject bundle, ) { - _startActivityFromFragment1(reference.pointer, fragment.reference.pointer, - intent.reference.pointer, i, bundle.reference.pointer) + _startActivityFromFragment1( + reference.pointer, + _id_startActivityFromFragment1 as jni.JMethodIDPtr, + fragment.reference.pointer, + intent.reference.pointer, + i, + bundle.reference.pointer) .check(); } - static final _startIntentSenderFromChild = jniLookup< + static final _id_startIntentSenderFromChild = _class.instanceMethodId( + r"startIntentSenderFromChild", + r"(Landroid/app/Activity;Landroid/content/IntentSender;ILandroid/content/Intent;III)V", + ); + + static final _startIntentSenderFromChild = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32)>>("Activity__startIntentSenderFromChild") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64 + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, int, @@ -13590,6 +19612,7 @@ class Activity extends jni.JObject { ) { _startIntentSenderFromChild( reference.pointer, + _id_startIntentSenderFromChild as jni.JMethodIDPtr, activity.reference.pointer, intentSender.reference.pointer, i, @@ -13600,22 +19623,31 @@ class Activity extends jni.JObject { .check(); } - static final _startIntentSenderFromChild1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32, - ffi.Pointer)>>( - "Activity__startIntentSenderFromChild1") + static final _id_startIntentSenderFromChild1 = _class.instanceMethodId( + r"startIntentSenderFromChild", + r"(Landroid/app/Activity;Landroid/content/IntentSender;ILandroid/content/Intent;IIILandroid/os/Bundle;)V", + ); + + static final _startIntentSenderFromChild1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, int, @@ -13638,6 +19670,7 @@ class Activity extends jni.JObject { ) { _startIntentSenderFromChild1( reference.pointer, + _id_startIntentSenderFromChild1 as jni.JMethodIDPtr, activity.reference.pointer, intentSender.reference.pointer, i, @@ -13649,29 +19682,45 @@ class Activity extends jni.JObject { .check(); } - static final _overridePendingTransition = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Int32)>>("Activity__overridePendingTransition") - .asFunction, int, int)>(); + static final _id_overridePendingTransition = _class.instanceMethodId( + r"overridePendingTransition", + r"(II)V", + ); + + static final _overridePendingTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.VarArgs<(ffi.Int64, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int)>(); /// from: public void overridePendingTransition(int i, int i1) void overridePendingTransition( int i, int i1, ) { - _overridePendingTransition(reference.pointer, i, i1).check(); + _overridePendingTransition(reference.pointer, + _id_overridePendingTransition as jni.JMethodIDPtr, i, i1) + .check(); } - static final _overridePendingTransition1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Int32)>>("Activity__overridePendingTransition1") + static final _id_overridePendingTransition1 = _class.instanceMethodId( + r"overridePendingTransition", + r"(III)V", + ); + + static final _overridePendingTransition1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Int64, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, int, int, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int, int)>(); /// from: public void overridePendingTransition(int i, int i1, int i2) void overridePendingTransition1( @@ -13679,258 +19728,488 @@ class Activity extends jni.JObject { int i1, int i2, ) { - _overridePendingTransition1(reference.pointer, i, i1, i2).check(); + _overridePendingTransition1(reference.pointer, + _id_overridePendingTransition1 as jni.JMethodIDPtr, i, i1, i2) + .check(); } - static final _setResult = jniLookup< + static final _id_setResult = _class.instanceMethodId( + r"setResult", + r"(I)V", + ); + + static final _setResult = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__setResult") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void setResult(int i) void setResult( int i, ) { - _setResult(reference.pointer, i).check(); + _setResult(reference.pointer, _id_setResult as jni.JMethodIDPtr, i).check(); } - static final _setResult1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__setResult1") + static final _id_setResult1 = _class.instanceMethodId( + r"setResult", + r"(ILandroid/content/Intent;)V", + ); + + static final _setResult1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: public final void setResult(int i, android.content.Intent intent) void setResult1( int i, Intent intent, ) { - _setResult1(reference.pointer, i, intent.reference.pointer).check(); + _setResult1(reference.pointer, _id_setResult1 as jni.JMethodIDPtr, i, + intent.reference.pointer) + .check(); } - static final _getReferrer = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getReferrer") - .asFunction)>(); + static final _id_getReferrer = _class.instanceMethodId( + r"getReferrer", + r"()Landroid/net/Uri;", + ); + + static final _getReferrer = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.net.Uri getReferrer() /// The returned object must be released after use, by calling the [release] method. jni.JObject getReferrer() { - return _getReferrer(reference.pointer).object(const jni.JObjectType()); + return _getReferrer(reference.pointer, _id_getReferrer as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _onProvideReferrer = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onProvideReferrer") - .asFunction)>(); + static final _id_onProvideReferrer = _class.instanceMethodId( + r"onProvideReferrer", + r"()Landroid/net/Uri;", + ); + + static final _onProvideReferrer = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.net.Uri onProvideReferrer() /// The returned object must be released after use, by calling the [release] method. jni.JObject onProvideReferrer() { - return _onProvideReferrer(reference.pointer) + return _onProvideReferrer( + reference.pointer, _id_onProvideReferrer as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _getCallingPackage = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getCallingPackage") - .asFunction)>(); + static final _id_getCallingPackage = _class.instanceMethodId( + r"getCallingPackage", + r"()Ljava/lang/String;", + ); + + static final _getCallingPackage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getCallingPackage() /// The returned object must be released after use, by calling the [release] method. jni.JString getCallingPackage() { - return _getCallingPackage(reference.pointer) + return _getCallingPackage( + reference.pointer, _id_getCallingPackage as jni.JMethodIDPtr) .object(const jni.JStringType()); } - static final _getCallingActivity = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getCallingActivity") - .asFunction)>(); + static final _id_getCallingActivity = _class.instanceMethodId( + r"getCallingActivity", + r"()Landroid/content/ComponentName;", + ); + + static final _getCallingActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.ComponentName getCallingActivity() /// The returned object must be released after use, by calling the [release] method. jni.JObject getCallingActivity() { - return _getCallingActivity(reference.pointer) + return _getCallingActivity( + reference.pointer, _id_getCallingActivity as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _setVisible = jniLookup< + static final _id_setVisible = _class.instanceMethodId( + r"setVisible", + r"(Z)V", + ); + + static final _setVisible = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Uint8)>>("Activity__setVisible") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setVisible(boolean z) void setVisible( bool z, ) { - _setVisible(reference.pointer, z ? 1 : 0).check(); + _setVisible( + reference.pointer, _id_setVisible as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _isFinishing = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isFinishing") - .asFunction)>(); + static final _id_isFinishing = _class.instanceMethodId( + r"isFinishing", + r"()Z", + ); + + static final _isFinishing = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isFinishing() bool isFinishing() { - return _isFinishing(reference.pointer).boolean; + return _isFinishing(reference.pointer, _id_isFinishing as jni.JMethodIDPtr) + .boolean; } - static final _isDestroyed = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isDestroyed") - .asFunction)>(); + static final _id_isDestroyed = _class.instanceMethodId( + r"isDestroyed", + r"()Z", + ); + + static final _isDestroyed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isDestroyed() bool isDestroyed() { - return _isDestroyed(reference.pointer).boolean; + return _isDestroyed(reference.pointer, _id_isDestroyed as jni.JMethodIDPtr) + .boolean; } - static final _isChangingConfigurations = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isChangingConfigurations") - .asFunction)>(); + static final _id_isChangingConfigurations = _class.instanceMethodId( + r"isChangingConfigurations", + r"()Z", + ); + + static final _isChangingConfigurations = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isChangingConfigurations() bool isChangingConfigurations() { - return _isChangingConfigurations(reference.pointer).boolean; + return _isChangingConfigurations( + reference.pointer, _id_isChangingConfigurations as jni.JMethodIDPtr) + .boolean; } - static final _recreate = jniLookup< - ffi - .NativeFunction)>>( - "Activity__recreate") - .asFunction)>(); + static final _id_recreate = _class.instanceMethodId( + r"recreate", + r"()V", + ); + + static final _recreate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void recreate() void recreate() { - _recreate(reference.pointer).check(); + _recreate(reference.pointer, _id_recreate as jni.JMethodIDPtr).check(); } - static final _finish = jniLookup< - ffi - .NativeFunction)>>( - "Activity__finish") - .asFunction)>(); + static final _id_finish = _class.instanceMethodId( + r"finish", + r"()V", + ); + + static final _finish = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void finish() void finish() { - _finish(reference.pointer).check(); + _finish(reference.pointer, _id_finish as jni.JMethodIDPtr).check(); } - static final _finishAffinity = jniLookup< - ffi - .NativeFunction)>>( - "Activity__finishAffinity") - .asFunction)>(); + static final _id_finishAffinity = _class.instanceMethodId( + r"finishAffinity", + r"()V", + ); + + static final _finishAffinity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void finishAffinity() void finishAffinity() { - _finishAffinity(reference.pointer).check(); + _finishAffinity(reference.pointer, _id_finishAffinity as jni.JMethodIDPtr) + .check(); } - static final _finishFromChild = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__finishFromChild") + static final _id_finishFromChild = _class.instanceMethodId( + r"finishFromChild", + r"(Landroid/app/Activity;)V", + ); + + static final _finishFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void finishFromChild(android.app.Activity activity) void finishFromChild( Activity activity, ) { - _finishFromChild(reference.pointer, activity.reference.pointer).check(); + _finishFromChild(reference.pointer, _id_finishFromChild as jni.JMethodIDPtr, + activity.reference.pointer) + .check(); } - static final _finishAfterTransition = jniLookup< - ffi - .NativeFunction)>>( - "Activity__finishAfterTransition") - .asFunction)>(); + static final _id_finishAfterTransition = _class.instanceMethodId( + r"finishAfterTransition", + r"()V", + ); + + static final _finishAfterTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void finishAfterTransition() void finishAfterTransition() { - _finishAfterTransition(reference.pointer).check(); + _finishAfterTransition( + reference.pointer, _id_finishAfterTransition as jni.JMethodIDPtr) + .check(); } - static final _finishActivity = jniLookup< + static final _id_finishActivity = _class.instanceMethodId( + r"finishActivity", + r"(I)V", + ); + + static final _finishActivity = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__finishActivity") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void finishActivity(int i) void finishActivity( int i, ) { - _finishActivity(reference.pointer, i).check(); + _finishActivity( + reference.pointer, _id_finishActivity as jni.JMethodIDPtr, i) + .check(); } - static final _finishActivityFromChild = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__finishActivityFromChild") + static final _id_finishActivityFromChild = _class.instanceMethodId( + r"finishActivityFromChild", + r"(Landroid/app/Activity;I)V", + ); + + static final _finishActivityFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public void finishActivityFromChild(android.app.Activity activity, int i) void finishActivityFromChild( Activity activity, int i, ) { - _finishActivityFromChild(reference.pointer, activity.reference.pointer, i) + _finishActivityFromChild( + reference.pointer, + _id_finishActivityFromChild as jni.JMethodIDPtr, + activity.reference.pointer, + i) .check(); } - static final _finishAndRemoveTask = jniLookup< - ffi - .NativeFunction)>>( - "Activity__finishAndRemoveTask") - .asFunction)>(); + static final _id_finishAndRemoveTask = _class.instanceMethodId( + r"finishAndRemoveTask", + r"()V", + ); + + static final _finishAndRemoveTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void finishAndRemoveTask() void finishAndRemoveTask() { - _finishAndRemoveTask(reference.pointer).check(); + _finishAndRemoveTask( + reference.pointer, _id_finishAndRemoveTask as jni.JMethodIDPtr) + .check(); } - static final _releaseInstance = jniLookup< - ffi - .NativeFunction)>>( - "Activity__releaseInstance") - .asFunction)>(); + static final _id_releaseInstance = _class.instanceMethodId( + r"releaseInstance", + r"()Z", + ); + + static final _releaseInstance = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean releaseInstance() bool releaseInstance() { - return _releaseInstance(reference.pointer).boolean; + return _releaseInstance( + reference.pointer, _id_releaseInstance as jni.JMethodIDPtr) + .boolean; } - static final _onActivityResult = jniLookup< + static final _id_onActivityResult = _class.instanceMethodId( + r"onActivityResult", + r"(IILandroid/content/Intent;)V", + ); + + static final _onActivityResult = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Int32, - ffi.Int32, - ffi.Pointer)>>("Activity__onActivityResult") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, int, ffi.Pointer)>(); /// from: protected void onActivityResult(int i, int i1, android.content.Intent intent) void onActivityResult( @@ -13938,36 +20217,63 @@ class Activity extends jni.JObject { int i1, Intent intent, ) { - _onActivityResult(reference.pointer, i, i1, intent.reference.pointer) + _onActivityResult( + reference.pointer, + _id_onActivityResult as jni.JMethodIDPtr, + i, + i1, + intent.reference.pointer) .check(); } - static final _onActivityReenter = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int32, - ffi.Pointer)>>("Activity__onActivityReenter") + static final _id_onActivityReenter = _class.instanceMethodId( + r"onActivityReenter", + r"(ILandroid/content/Intent;)V", + ); + + static final _onActivityReenter = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: public void onActivityReenter(int i, android.content.Intent intent) void onActivityReenter( int i, Intent intent, ) { - _onActivityReenter(reference.pointer, i, intent.reference.pointer).check(); + _onActivityReenter( + reference.pointer, + _id_onActivityReenter as jni.JMethodIDPtr, + i, + intent.reference.pointer) + .check(); } - static final _createPendingResult = jniLookup< + static final _id_createPendingResult = _class.instanceMethodId( + r"createPendingResult", + r"(ILandroid/content/Intent;I)Landroid/app/PendingIntent;", + ); + + static final _createPendingResult = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Int32, - ffi.Pointer, - ffi.Int32)>>("Activity__createPendingResult") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Int64, + ffi.Pointer, + ffi.Int64 + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer, int)>(); /// from: public android.app.PendingIntent createPendingResult(int i, android.content.Intent intent, int i1) /// The returned object must be released after use, by calling the [release] method. @@ -13977,400 +20283,727 @@ class Activity extends jni.JObject { int i1, ) { return _createPendingResult( - reference.pointer, i, intent.reference.pointer, i1) + reference.pointer, + _id_createPendingResult as jni.JMethodIDPtr, + i, + intent.reference.pointer, + i1) .object(const jni.JObjectType()); } - static final _setRequestedOrientation = jniLookup< + static final _id_setRequestedOrientation = _class.instanceMethodId( + r"setRequestedOrientation", + r"(I)V", + ); + + static final _setRequestedOrientation = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__setRequestedOrientation") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setRequestedOrientation(int i) void setRequestedOrientation( int i, ) { - _setRequestedOrientation(reference.pointer, i).check(); + _setRequestedOrientation(reference.pointer, + _id_setRequestedOrientation as jni.JMethodIDPtr, i) + .check(); } - static final _getRequestedOrientation = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getRequestedOrientation") - .asFunction)>(); + static final _id_getRequestedOrientation = _class.instanceMethodId( + r"getRequestedOrientation", + r"()I", + ); + + static final _getRequestedOrientation = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int getRequestedOrientation() int getRequestedOrientation() { - return _getRequestedOrientation(reference.pointer).integer; + return _getRequestedOrientation( + reference.pointer, _id_getRequestedOrientation as jni.JMethodIDPtr) + .integer; } - static final _getTaskId = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getTaskId") - .asFunction)>(); + static final _id_getTaskId = _class.instanceMethodId( + r"getTaskId", + r"()I", + ); + + static final _getTaskId = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int getTaskId() int getTaskId() { - return _getTaskId(reference.pointer).integer; + return _getTaskId(reference.pointer, _id_getTaskId as jni.JMethodIDPtr) + .integer; } - static final _isTaskRoot = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isTaskRoot") - .asFunction)>(); + static final _id_isTaskRoot = _class.instanceMethodId( + r"isTaskRoot", + r"()Z", + ); + + static final _isTaskRoot = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isTaskRoot() bool isTaskRoot() { - return _isTaskRoot(reference.pointer).boolean; + return _isTaskRoot(reference.pointer, _id_isTaskRoot as jni.JMethodIDPtr) + .boolean; } - static final _moveTaskToBack = jniLookup< + static final _id_moveTaskToBack = _class.instanceMethodId( + r"moveTaskToBack", + r"(Z)Z", + ); + + static final _moveTaskToBack = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__moveTaskToBack") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public boolean moveTaskToBack(boolean z) bool moveTaskToBack( bool z, ) { - return _moveTaskToBack(reference.pointer, z ? 1 : 0).boolean; + return _moveTaskToBack(reference.pointer, + _id_moveTaskToBack as jni.JMethodIDPtr, z ? 1 : 0) + .boolean; } - static final _getLocalClassName = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getLocalClassName") - .asFunction)>(); + static final _id_getLocalClassName = _class.instanceMethodId( + r"getLocalClassName", + r"()Ljava/lang/String;", + ); + + static final _getLocalClassName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String getLocalClassName() /// The returned object must be released after use, by calling the [release] method. jni.JString getLocalClassName() { - return _getLocalClassName(reference.pointer) + return _getLocalClassName( + reference.pointer, _id_getLocalClassName as jni.JMethodIDPtr) .object(const jni.JStringType()); } - static final _getComponentName = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getComponentName") - .asFunction)>(); + static final _id_getComponentName = _class.instanceMethodId( + r"getComponentName", + r"()Landroid/content/ComponentName;", + ); + + static final _getComponentName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.ComponentName getComponentName() /// The returned object must be released after use, by calling the [release] method. jni.JObject getComponentName() { - return _getComponentName(reference.pointer).object(const jni.JObjectType()); + return _getComponentName( + reference.pointer, _id_getComponentName as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getPreferences = jniLookup< + static final _id_getPreferences = _class.instanceMethodId( + r"getPreferences", + r"(I)Landroid/content/SharedPreferences;", + ); + + static final _getPreferences = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__getPreferences") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public android.content.SharedPreferences getPreferences(int i) /// The returned object must be released after use, by calling the [release] method. jni.JObject getPreferences( int i, ) { - return _getPreferences(reference.pointer, i) + return _getPreferences( + reference.pointer, _id_getPreferences as jni.JMethodIDPtr, i) .object(const jni.JObjectType()); } - static final _isLaunchedFromBubble = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isLaunchedFromBubble") - .asFunction)>(); + static final _id_isLaunchedFromBubble = _class.instanceMethodId( + r"isLaunchedFromBubble", + r"()Z", + ); + + static final _isLaunchedFromBubble = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isLaunchedFromBubble() bool isLaunchedFromBubble() { - return _isLaunchedFromBubble(reference.pointer).boolean; + return _isLaunchedFromBubble( + reference.pointer, _id_isLaunchedFromBubble as jni.JMethodIDPtr) + .boolean; } - static final _getSystemService = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__getSystemService") + static final _id_getSystemService = _class.instanceMethodId( + r"getSystemService", + r"(Ljava/lang/String;)Ljava/lang/Object;", + ); + + static final _getSystemService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.lang.Object getSystemService(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. jni.JObject getSystemService( jni.JString string, ) { - return _getSystemService(reference.pointer, string.reference.pointer) + return _getSystemService(reference.pointer, + _id_getSystemService as jni.JMethodIDPtr, string.reference.pointer) .object(const jni.JObjectType()); } - static final _setTitle = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__setTitle") + static final _id_setTitle = _class.instanceMethodId( + r"setTitle", + r"(Ljava/lang/CharSequence;)V", + ); + + static final _setTitle = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setTitle(java.lang.CharSequence charSequence) void setTitle( jni.JObject charSequence, ) { - _setTitle(reference.pointer, charSequence.reference.pointer).check(); + _setTitle(reference.pointer, _id_setTitle as jni.JMethodIDPtr, + charSequence.reference.pointer) + .check(); } - static final _setTitle1 = jniLookup< + static final _id_setTitle1 = _class.instanceMethodId( + r"setTitle", + r"(I)V", + ); + + static final _setTitle1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__setTitle1") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setTitle(int i) void setTitle1( int i, ) { - _setTitle1(reference.pointer, i).check(); + _setTitle1(reference.pointer, _id_setTitle1 as jni.JMethodIDPtr, i).check(); } - static final _setTitleColor = jniLookup< + static final _id_setTitleColor = _class.instanceMethodId( + r"setTitleColor", + r"(I)V", + ); + + static final _setTitleColor = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__setTitleColor") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setTitleColor(int i) void setTitleColor( int i, ) { - _setTitleColor(reference.pointer, i).check(); + _setTitleColor(reference.pointer, _id_setTitleColor as jni.JMethodIDPtr, i) + .check(); } - static final _getTitle = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getTitle") - .asFunction)>(); + static final _id_getTitle = _class.instanceMethodId( + r"getTitle", + r"()Ljava/lang/CharSequence;", + ); + + static final _getTitle = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final java.lang.CharSequence getTitle() /// The returned object must be released after use, by calling the [release] method. jni.JObject getTitle() { - return _getTitle(reference.pointer).object(const jni.JObjectType()); + return _getTitle(reference.pointer, _id_getTitle as jni.JMethodIDPtr) + .object(const jni.JObjectType()); } - static final _getTitleColor = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getTitleColor") - .asFunction)>(); + static final _id_getTitleColor = _class.instanceMethodId( + r"getTitleColor", + r"()I", + ); + + static final _getTitleColor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final int getTitleColor() int getTitleColor() { - return _getTitleColor(reference.pointer).integer; + return _getTitleColor( + reference.pointer, _id_getTitleColor as jni.JMethodIDPtr) + .integer; } - static final _onTitleChanged = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__onTitleChanged") + static final _id_onTitleChanged = _class.instanceMethodId( + r"onTitleChanged", + r"(Ljava/lang/CharSequence;I)V", + ); + + static final _onTitleChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: protected void onTitleChanged(java.lang.CharSequence charSequence, int i) void onTitleChanged( jni.JObject charSequence, int i, ) { - _onTitleChanged(reference.pointer, charSequence.reference.pointer, i) + _onTitleChanged(reference.pointer, _id_onTitleChanged as jni.JMethodIDPtr, + charSequence.reference.pointer, i) .check(); } - static final _onChildTitleChanged = jniLookup< + static final _id_onChildTitleChanged = _class.instanceMethodId( + r"onChildTitleChanged", + r"(Landroid/app/Activity;Ljava/lang/CharSequence;)V", + ); + + static final _onChildTitleChanged = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer)>>("Activity__onChildTitleChanged") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: protected void onChildTitleChanged(android.app.Activity activity, java.lang.CharSequence charSequence) void onChildTitleChanged( Activity activity, jni.JObject charSequence, ) { - _onChildTitleChanged(reference.pointer, activity.reference.pointer, + _onChildTitleChanged( + reference.pointer, + _id_onChildTitleChanged as jni.JMethodIDPtr, + activity.reference.pointer, charSequence.reference.pointer) .check(); } - static final _setTaskDescription = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__setTaskDescription") + static final _id_setTaskDescription = _class.instanceMethodId( + r"setTaskDescription", + r"(Landroid/app/ActivityManager$TaskDescription;)V", + ); + + static final _setTaskDescription = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setTaskDescription(android.app.ActivityManager$TaskDescription taskDescription) void setTaskDescription( jni.JObject taskDescription, ) { - _setTaskDescription(reference.pointer, taskDescription.reference.pointer) + _setTaskDescription( + reference.pointer, + _id_setTaskDescription as jni.JMethodIDPtr, + taskDescription.reference.pointer) .check(); } - static final _setProgressBarVisibility = jniLookup< + static final _id_setProgressBarVisibility = _class.instanceMethodId( + r"setProgressBarVisibility", + r"(Z)V", + ); + + static final _setProgressBarVisibility = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setProgressBarVisibility") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void setProgressBarVisibility(boolean z) void setProgressBarVisibility( bool z, ) { - _setProgressBarVisibility(reference.pointer, z ? 1 : 0).check(); + _setProgressBarVisibility(reference.pointer, + _id_setProgressBarVisibility as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _setProgressBarIndeterminateVisibility = jniLookup< + static final _id_setProgressBarIndeterminateVisibility = + _class.instanceMethodId( + r"setProgressBarIndeterminateVisibility", + r"(Z)V", + ); + + static final _setProgressBarIndeterminateVisibility = + ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Uint8)>>( - "Activity__setProgressBarIndeterminateVisibility") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void setProgressBarIndeterminateVisibility(boolean z) void setProgressBarIndeterminateVisibility( bool z, ) { - _setProgressBarIndeterminateVisibility(reference.pointer, z ? 1 : 0) + _setProgressBarIndeterminateVisibility( + reference.pointer, + _id_setProgressBarIndeterminateVisibility as jni.JMethodIDPtr, + z ? 1 : 0) .check(); } - static final _setProgressBarIndeterminate = jniLookup< + static final _id_setProgressBarIndeterminate = _class.instanceMethodId( + r"setProgressBarIndeterminate", + r"(Z)V", + ); + + static final _setProgressBarIndeterminate = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setProgressBarIndeterminate") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void setProgressBarIndeterminate(boolean z) void setProgressBarIndeterminate( bool z, ) { - _setProgressBarIndeterminate(reference.pointer, z ? 1 : 0).check(); + _setProgressBarIndeterminate(reference.pointer, + _id_setProgressBarIndeterminate as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _setProgress = jniLookup< + static final _id_setProgress = _class.instanceMethodId( + r"setProgress", + r"(I)V", + ); + + static final _setProgress = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int32)>>("Activity__setProgress") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void setProgress(int i) void setProgress( int i, ) { - _setProgress(reference.pointer, i).check(); + _setProgress(reference.pointer, _id_setProgress as jni.JMethodIDPtr, i) + .check(); } - static final _setSecondaryProgress = jniLookup< + static final _id_setSecondaryProgress = _class.instanceMethodId( + r"setSecondaryProgress", + r"(I)V", + ); + + static final _setSecondaryProgress = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__setSecondaryProgress") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void setSecondaryProgress(int i) void setSecondaryProgress( int i, ) { - _setSecondaryProgress(reference.pointer, i).check(); + _setSecondaryProgress( + reference.pointer, _id_setSecondaryProgress as jni.JMethodIDPtr, i) + .check(); } - static final _setVolumeControlStream = jniLookup< + static final _id_setVolumeControlStream = _class.instanceMethodId( + r"setVolumeControlStream", + r"(I)V", + ); + + static final _setVolumeControlStream = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Int32)>>("Activity__setVolumeControlStream") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public final void setVolumeControlStream(int i) void setVolumeControlStream( int i, ) { - _setVolumeControlStream(reference.pointer, i).check(); + _setVolumeControlStream(reference.pointer, + _id_setVolumeControlStream as jni.JMethodIDPtr, i) + .check(); } - static final _getVolumeControlStream = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getVolumeControlStream") - .asFunction)>(); + static final _id_getVolumeControlStream = _class.instanceMethodId( + r"getVolumeControlStream", + r"()I", + ); + + static final _getVolumeControlStream = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final int getVolumeControlStream() int getVolumeControlStream() { - return _getVolumeControlStream(reference.pointer).integer; + return _getVolumeControlStream( + reference.pointer, _id_getVolumeControlStream as jni.JMethodIDPtr) + .integer; } - static final _setMediaController = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__setMediaController") + static final _id_setMediaController = _class.instanceMethodId( + r"setMediaController", + r"(Landroid/media/session/MediaController;)V", + ); + + static final _setMediaController = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final void setMediaController(android.media.session.MediaController mediaController) void setMediaController( jni.JObject mediaController, ) { - _setMediaController(reference.pointer, mediaController.reference.pointer) + _setMediaController( + reference.pointer, + _id_setMediaController as jni.JMethodIDPtr, + mediaController.reference.pointer) .check(); } - static final _getMediaController = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getMediaController") - .asFunction)>(); + static final _id_getMediaController = _class.instanceMethodId( + r"getMediaController", + r"()Landroid/media/session/MediaController;", + ); + + static final _getMediaController = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final android.media.session.MediaController getMediaController() /// The returned object must be released after use, by calling the [release] method. jni.JObject getMediaController() { - return _getMediaController(reference.pointer) + return _getMediaController( + reference.pointer, _id_getMediaController as jni.JMethodIDPtr) .object(const jni.JObjectType()); } - static final _runOnUiThread = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__runOnUiThread") + static final _id_runOnUiThread = _class.instanceMethodId( + r"runOnUiThread", + r"(Ljava/lang/Runnable;)V", + ); + + static final _runOnUiThread = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final void runOnUiThread(java.lang.Runnable runnable) void runOnUiThread( jni.JObject runnable, ) { - _runOnUiThread(reference.pointer, runnable.reference.pointer).check(); + _runOnUiThread(reference.pointer, _id_runOnUiThread as jni.JMethodIDPtr, + runnable.reference.pointer) + .check(); } - static final _onCreateView = jniLookup< + static final _id_onCreateView = _class.instanceMethodId( + r"onCreateView", + r"(Ljava/lang/String;Landroid/content/Context;Landroid/util/AttributeSet;)Landroid/view/View;", + ); + + static final _onCreateView = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__onCreateView") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public android.view.View onCreateView(java.lang.String string, android.content.Context context, android.util.AttributeSet attributeSet) /// The returned object must be released after use, by calling the [release] method. @@ -14379,22 +21012,36 @@ class Activity extends jni.JObject { Context context, jni.JObject attributeSet, ) { - return _onCreateView(reference.pointer, string.reference.pointer, - context.reference.pointer, attributeSet.reference.pointer) + return _onCreateView( + reference.pointer, + _id_onCreateView as jni.JMethodIDPtr, + string.reference.pointer, + context.reference.pointer, + attributeSet.reference.pointer) .object(const jni.JObjectType()); } - static final _onCreateView1 = jniLookup< + static final _id_onCreateView1 = _class.instanceMethodId( + r"onCreateView", + r"(Landroid/view/View;Ljava/lang/String;Landroid/content/Context;Landroid/util/AttributeSet;)Landroid/view/View;", + ); + + static final _onCreateView1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__onCreateView1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallObjectMethod") .asFunction< jni.JniResult Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -14410,6 +21057,7 @@ class Activity extends jni.JObject { ) { return _onCreateView1( reference.pointer, + _id_onCreateView1 as jni.JMethodIDPtr, view.reference.pointer, string.reference.pointer, context.reference.pointer, @@ -14417,17 +21065,27 @@ class Activity extends jni.JObject { .object(const jni.JObjectType()); } - static final _dump = jniLookup< + static final _id_dump = _class.instanceMethodId( + r"dump", + r"(Ljava/lang/String;Ljava/io/FileDescriptor;Ljava/io/PrintWriter;[Ljava/lang/String;)V", + ); + + static final _dump = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__dump") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( + jni.JThrowablePtr Function( ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -14442,6 +21100,7 @@ class Activity extends jni.JObject { ) { _dump( reference.pointer, + _id_dump as jni.JMethodIDPtr, string.reference.pointer, fileDescriptor.reference.pointer, printWriter.reference.pointer, @@ -14449,85 +21108,160 @@ class Activity extends jni.JObject { .check(); } - static final _isImmersive = jniLookup< - ffi - .NativeFunction)>>( - "Activity__isImmersive") - .asFunction)>(); + static final _id_isImmersive = _class.instanceMethodId( + r"isImmersive", + r"()Z", + ); + + static final _isImmersive = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public boolean isImmersive() bool isImmersive() { - return _isImmersive(reference.pointer).boolean; + return _isImmersive(reference.pointer, _id_isImmersive as jni.JMethodIDPtr) + .boolean; } - static final _setTranslucent = jniLookup< + static final _id_setTranslucent = _class.instanceMethodId( + r"setTranslucent", + r"(Z)Z", + ); + + static final _setTranslucent = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setTranslucent") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public boolean setTranslucent(boolean z) bool setTranslucent( bool z, ) { - return _setTranslucent(reference.pointer, z ? 1 : 0).boolean; + return _setTranslucent(reference.pointer, + _id_setTranslucent as jni.JMethodIDPtr, z ? 1 : 0) + .boolean; } - static final _requestVisibleBehind = jniLookup< + static final _id_requestVisibleBehind = _class.instanceMethodId( + r"requestVisibleBehind", + r"(Z)Z", + ); + + static final _requestVisibleBehind = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__requestVisibleBehind") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallBooleanMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public boolean requestVisibleBehind(boolean z) bool requestVisibleBehind( bool z, ) { - return _requestVisibleBehind(reference.pointer, z ? 1 : 0).boolean; + return _requestVisibleBehind(reference.pointer, + _id_requestVisibleBehind as jni.JMethodIDPtr, z ? 1 : 0) + .boolean; } - static final _onVisibleBehindCanceled = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onVisibleBehindCanceled") - .asFunction)>(); + static final _id_onVisibleBehindCanceled = _class.instanceMethodId( + r"onVisibleBehindCanceled", + r"()V", + ); + + static final _onVisibleBehindCanceled = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onVisibleBehindCanceled() void onVisibleBehindCanceled() { - _onVisibleBehindCanceled(reference.pointer).check(); + _onVisibleBehindCanceled( + reference.pointer, _id_onVisibleBehindCanceled as jni.JMethodIDPtr) + .check(); } - static final _onEnterAnimationComplete = jniLookup< - ffi - .NativeFunction)>>( - "Activity__onEnterAnimationComplete") - .asFunction)>(); + static final _id_onEnterAnimationComplete = _class.instanceMethodId( + r"onEnterAnimationComplete", + r"()V", + ); + + static final _onEnterAnimationComplete = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void onEnterAnimationComplete() void onEnterAnimationComplete() { - _onEnterAnimationComplete(reference.pointer).check(); + _onEnterAnimationComplete( + reference.pointer, _id_onEnterAnimationComplete as jni.JMethodIDPtr) + .check(); } - static final _setImmersive = jniLookup< + static final _id_setImmersive = _class.instanceMethodId( + r"setImmersive", + r"(Z)V", + ); + + static final _setImmersive = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Uint8)>>("Activity__setImmersive") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setImmersive(boolean z) void setImmersive( bool z, ) { - _setImmersive(reference.pointer, z ? 1 : 0).check(); + _setImmersive( + reference.pointer, _id_setImmersive as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _setVrModeEnabled = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Uint8, - ffi.Pointer)>>("Activity__setVrModeEnabled") + static final _id_setVrModeEnabled = _class.instanceMethodId( + r"setVrModeEnabled", + r"(ZLandroid/content/ComponentName;)V", + ); + + static final _setVrModeEnabled = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); /// from: public void setVrModeEnabled(boolean z, android.content.ComponentName componentName) void setVrModeEnabled( @@ -14535,36 +21269,54 @@ class Activity extends jni.JObject { jni.JObject componentName, ) { _setVrModeEnabled( - reference.pointer, z ? 1 : 0, componentName.reference.pointer) + reference.pointer, + _id_setVrModeEnabled as jni.JMethodIDPtr, + z ? 1 : 0, + componentName.reference.pointer) .check(); } - static final _startActionMode = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__startActionMode") + static final _id_startActionMode = _class.instanceMethodId( + r"startActionMode", + r"(Landroid/view/ActionMode$Callback;)Landroid/view/ActionMode;", + ); + + static final _startActionMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.view.ActionMode startActionMode(android.view.ActionMode$Callback callback) /// The returned object must be released after use, by calling the [release] method. jni.JObject startActionMode( jni.JObject callback, ) { - return _startActionMode(reference.pointer, callback.reference.pointer) + return _startActionMode(reference.pointer, + _id_startActionMode as jni.JMethodIDPtr, callback.reference.pointer) .object(const jni.JObjectType()); } - static final _startActionMode1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__startActionMode1") + static final _id_startActionMode1 = _class.instanceMethodId( + r"startActionMode", + r"(Landroid/view/ActionMode$Callback;I)Landroid/view/ActionMode;", + ); + + static final _startActionMode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.view.ActionMode startActionMode(android.view.ActionMode$Callback callback, int i) /// The returned object must be released after use, by calling the [release] method. @@ -14572,18 +21324,29 @@ class Activity extends jni.JObject { jni.JObject callback, int i, ) { - return _startActionMode1(reference.pointer, callback.reference.pointer, i) + return _startActionMode1( + reference.pointer, + _id_startActionMode1 as jni.JMethodIDPtr, + callback.reference.pointer, + i) .object(const jni.JObjectType()); } - static final _onWindowStartingActionMode = jniLookup< + static final _id_onWindowStartingActionMode = _class.instanceMethodId( + r"onWindowStartingActionMode", + r"(Landroid/view/ActionMode$Callback;)Landroid/view/ActionMode;", + ); + + static final _onWindowStartingActionMode = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__onWindowStartingActionMode") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.view.ActionMode onWindowStartingActionMode(android.view.ActionMode$Callback callback) /// The returned object must be released after use, by calling the [release] method. @@ -14591,19 +21354,27 @@ class Activity extends jni.JObject { jni.JObject callback, ) { return _onWindowStartingActionMode( - reference.pointer, callback.reference.pointer) + reference.pointer, + _id_onWindowStartingActionMode as jni.JMethodIDPtr, + callback.reference.pointer) .object(const jni.JObjectType()); } - static final _onWindowStartingActionMode1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Int32)>>("Activity__onWindowStartingActionMode1") + static final _id_onWindowStartingActionMode1 = _class.instanceMethodId( + r"onWindowStartingActionMode", + r"(Landroid/view/ActionMode$Callback;I)Landroid/view/ActionMode;", + ); + + static final _onWindowStartingActionMode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public android.view.ActionMode onWindowStartingActionMode(android.view.ActionMode$Callback callback, int i) /// The returned object must be released after use, by calling the [release] method. @@ -14612,172 +21383,293 @@ class Activity extends jni.JObject { int i, ) { return _onWindowStartingActionMode1( - reference.pointer, callback.reference.pointer, i) + reference.pointer, + _id_onWindowStartingActionMode1 as jni.JMethodIDPtr, + callback.reference.pointer, + i) .object(const jni.JObjectType()); } - static final _onActionModeStarted = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onActionModeStarted") + static final _id_onActionModeStarted = _class.instanceMethodId( + r"onActionModeStarted", + r"(Landroid/view/ActionMode;)V", + ); + + static final _onActionModeStarted = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onActionModeStarted(android.view.ActionMode actionMode) void onActionModeStarted( jni.JObject actionMode, ) { - _onActionModeStarted(reference.pointer, actionMode.reference.pointer) + _onActionModeStarted( + reference.pointer, + _id_onActionModeStarted as jni.JMethodIDPtr, + actionMode.reference.pointer) .check(); } - static final _onActionModeFinished = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__onActionModeFinished") + static final _id_onActionModeFinished = _class.instanceMethodId( + r"onActionModeFinished", + r"(Landroid/view/ActionMode;)V", + ); + + static final _onActionModeFinished = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void onActionModeFinished(android.view.ActionMode actionMode) void onActionModeFinished( jni.JObject actionMode, ) { - _onActionModeFinished(reference.pointer, actionMode.reference.pointer) + _onActionModeFinished( + reference.pointer, + _id_onActionModeFinished as jni.JMethodIDPtr, + actionMode.reference.pointer) .check(); } - static final _shouldUpRecreateTask = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__shouldUpRecreateTask") + static final _id_shouldUpRecreateTask = _class.instanceMethodId( + r"shouldUpRecreateTask", + r"(Landroid/content/Intent;)Z", + ); + + static final _shouldUpRecreateTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean shouldUpRecreateTask(android.content.Intent intent) bool shouldUpRecreateTask( Intent intent, ) { - return _shouldUpRecreateTask(reference.pointer, intent.reference.pointer) + return _shouldUpRecreateTask( + reference.pointer, + _id_shouldUpRecreateTask as jni.JMethodIDPtr, + intent.reference.pointer) .boolean; } - static final _navigateUpTo = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Activity__navigateUpTo") + static final _id_navigateUpTo = _class.instanceMethodId( + r"navigateUpTo", + r"(Landroid/content/Intent;)Z", + ); + + static final _navigateUpTo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean navigateUpTo(android.content.Intent intent) bool navigateUpTo( Intent intent, ) { - return _navigateUpTo(reference.pointer, intent.reference.pointer).boolean; + return _navigateUpTo(reference.pointer, + _id_navigateUpTo as jni.JMethodIDPtr, intent.reference.pointer) + .boolean; } - static final _navigateUpToFromChild = jniLookup< + static final _id_navigateUpToFromChild = _class.instanceMethodId( + r"navigateUpToFromChild", + r"(Landroid/app/Activity;Landroid/content/Intent;)Z", + ); + + static final _navigateUpToFromChild = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Activity__navigateUpToFromChild") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public boolean navigateUpToFromChild(android.app.Activity activity, android.content.Intent intent) bool navigateUpToFromChild( Activity activity, Intent intent, ) { - return _navigateUpToFromChild(reference.pointer, activity.reference.pointer, + return _navigateUpToFromChild( + reference.pointer, + _id_navigateUpToFromChild as jni.JMethodIDPtr, + activity.reference.pointer, intent.reference.pointer) .boolean; } - static final _getParentActivityIntent = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getParentActivityIntent") - .asFunction)>(); + static final _id_getParentActivityIntent = _class.instanceMethodId( + r"getParentActivityIntent", + r"()Landroid/content/Intent;", + ); + + static final _getParentActivityIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.content.Intent getParentActivityIntent() /// The returned object must be released after use, by calling the [release] method. Intent getParentActivityIntent() { - return _getParentActivityIntent(reference.pointer) + return _getParentActivityIntent( + reference.pointer, _id_getParentActivityIntent as jni.JMethodIDPtr) .object(const $IntentType()); } - static final _setEnterSharedElementCallback = jniLookup< + static final _id_setEnterSharedElementCallback = _class.instanceMethodId( + r"setEnterSharedElementCallback", + r"(Landroid/app/SharedElementCallback;)V", + ); + + static final _setEnterSharedElementCallback = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__setEnterSharedElementCallback") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setEnterSharedElementCallback(android.app.SharedElementCallback sharedElementCallback) void setEnterSharedElementCallback( jni.JObject sharedElementCallback, ) { _setEnterSharedElementCallback( - reference.pointer, sharedElementCallback.reference.pointer) + reference.pointer, + _id_setEnterSharedElementCallback as jni.JMethodIDPtr, + sharedElementCallback.reference.pointer) .check(); } - static final _setExitSharedElementCallback = jniLookup< + static final _id_setExitSharedElementCallback = _class.instanceMethodId( + r"setExitSharedElementCallback", + r"(Landroid/app/SharedElementCallback;)V", + ); + + static final _setExitSharedElementCallback = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__setExitSharedElementCallback") + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallVoidMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void setExitSharedElementCallback(android.app.SharedElementCallback sharedElementCallback) void setExitSharedElementCallback( jni.JObject sharedElementCallback, ) { _setExitSharedElementCallback( - reference.pointer, sharedElementCallback.reference.pointer) + reference.pointer, + _id_setExitSharedElementCallback as jni.JMethodIDPtr, + sharedElementCallback.reference.pointer) .check(); } - static final _postponeEnterTransition = jniLookup< - ffi - .NativeFunction)>>( - "Activity__postponeEnterTransition") - .asFunction)>(); + static final _id_postponeEnterTransition = _class.instanceMethodId( + r"postponeEnterTransition", + r"()V", + ); + + static final _postponeEnterTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void postponeEnterTransition() void postponeEnterTransition() { - _postponeEnterTransition(reference.pointer).check(); + _postponeEnterTransition( + reference.pointer, _id_postponeEnterTransition as jni.JMethodIDPtr) + .check(); } - static final _startPostponedEnterTransition = jniLookup< - ffi - .NativeFunction)>>( - "Activity__startPostponedEnterTransition") - .asFunction)>(); + static final _id_startPostponedEnterTransition = _class.instanceMethodId( + r"startPostponedEnterTransition", + r"()V", + ); + + static final _startPostponedEnterTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void startPostponedEnterTransition() void startPostponedEnterTransition() { - _startPostponedEnterTransition(reference.pointer).check(); + _startPostponedEnterTransition(reference.pointer, + _id_startPostponedEnterTransition as jni.JMethodIDPtr) + .check(); } - static final _requestDragAndDropPermissions = jniLookup< + static final _id_requestDragAndDropPermissions = _class.instanceMethodId( + r"requestDragAndDropPermissions", + r"(Landroid/view/DragEvent;)Landroid/view/DragAndDropPermissions;", + ); + + static final _requestDragAndDropPermissions = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>>( - "Activity__requestDragAndDropPermissions") + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public android.view.DragAndDropPermissions requestDragAndDropPermissions(android.view.DragEvent dragEvent) /// The returned object must be released after use, by calling the [release] method. @@ -14785,105 +21677,200 @@ class Activity extends jni.JObject { jni.JObject dragEvent, ) { return _requestDragAndDropPermissions( - reference.pointer, dragEvent.reference.pointer) + reference.pointer, + _id_requestDragAndDropPermissions as jni.JMethodIDPtr, + dragEvent.reference.pointer) .object(const jni.JObjectType()); } - static final _startLockTask = jniLookup< - ffi - .NativeFunction)>>( - "Activity__startLockTask") - .asFunction)>(); + static final _id_startLockTask = _class.instanceMethodId( + r"startLockTask", + r"()V", + ); + + static final _startLockTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void startLockTask() void startLockTask() { - _startLockTask(reference.pointer).check(); + _startLockTask(reference.pointer, _id_startLockTask as jni.JMethodIDPtr) + .check(); } - static final _stopLockTask = jniLookup< - ffi - .NativeFunction)>>( - "Activity__stopLockTask") - .asFunction)>(); + static final _id_stopLockTask = _class.instanceMethodId( + r"stopLockTask", + r"()V", + ); + + static final _stopLockTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void stopLockTask() void stopLockTask() { - _stopLockTask(reference.pointer).check(); + _stopLockTask(reference.pointer, _id_stopLockTask as jni.JMethodIDPtr) + .check(); } - static final _showLockTaskEscapeMessage = jniLookup< - ffi - .NativeFunction)>>( - "Activity__showLockTaskEscapeMessage") - .asFunction)>(); + static final _id_showLockTaskEscapeMessage = _class.instanceMethodId( + r"showLockTaskEscapeMessage", + r"()V", + ); + + static final _showLockTaskEscapeMessage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public void showLockTaskEscapeMessage() void showLockTaskEscapeMessage() { - _showLockTaskEscapeMessage(reference.pointer).check(); + _showLockTaskEscapeMessage(reference.pointer, + _id_showLockTaskEscapeMessage as jni.JMethodIDPtr) + .check(); } - static final _setRecentsScreenshotEnabled = jniLookup< + static final _id_setRecentsScreenshotEnabled = _class.instanceMethodId( + r"setRecentsScreenshotEnabled", + r"(Z)V", + ); + + static final _setRecentsScreenshotEnabled = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setRecentsScreenshotEnabled") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setRecentsScreenshotEnabled(boolean z) void setRecentsScreenshotEnabled( bool z, ) { - _setRecentsScreenshotEnabled(reference.pointer, z ? 1 : 0).check(); + _setRecentsScreenshotEnabled(reference.pointer, + _id_setRecentsScreenshotEnabled as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _setShowWhenLocked = jniLookup< + static final _id_setShowWhenLocked = _class.instanceMethodId( + r"setShowWhenLocked", + r"(Z)V", + ); + + static final _setShowWhenLocked = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setShowWhenLocked") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setShowWhenLocked(boolean z) void setShowWhenLocked( bool z, ) { - _setShowWhenLocked(reference.pointer, z ? 1 : 0).check(); + _setShowWhenLocked(reference.pointer, + _id_setShowWhenLocked as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _setInheritShowWhenLocked = jniLookup< + static final _id_setInheritShowWhenLocked = _class.instanceMethodId( + r"setInheritShowWhenLocked", + r"(Z)V", + ); + + static final _setInheritShowWhenLocked = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setInheritShowWhenLocked") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setInheritShowWhenLocked(boolean z) void setInheritShowWhenLocked( bool z, ) { - _setInheritShowWhenLocked(reference.pointer, z ? 1 : 0).check(); + _setInheritShowWhenLocked(reference.pointer, + _id_setInheritShowWhenLocked as jni.JMethodIDPtr, z ? 1 : 0) + .check(); } - static final _setTurnScreenOn = jniLookup< + static final _id_setTurnScreenOn = _class.instanceMethodId( + r"setTurnScreenOn", + r"(Z)V", + ); + + static final _setTurnScreenOn = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Uint8)>>("Activity__setTurnScreenOn") - .asFunction, int)>(); + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallVoidMethod") + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public void setTurnScreenOn(boolean z) void setTurnScreenOn( bool z, ) { - _setTurnScreenOn(reference.pointer, z ? 1 : 0).check(); + _setTurnScreenOn(reference.pointer, _id_setTurnScreenOn as jni.JMethodIDPtr, + z ? 1 : 0) + .check(); } - static final _getOnBackInvokedDispatcher = jniLookup< - ffi - .NativeFunction)>>( - "Activity__getOnBackInvokedDispatcher") - .asFunction)>(); + static final _id_getOnBackInvokedDispatcher = _class.instanceMethodId( + r"getOnBackInvokedDispatcher", + r"()Landroid/window/OnBackInvokedDispatcher;", + ); + + static final _getOnBackInvokedDispatcher = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public android.window.OnBackInvokedDispatcher getOnBackInvokedDispatcher() /// The returned object must be released after use, by calling the [release] method. jni.JObject getOnBackInvokedDispatcher() { - return _getOnBackInvokedDispatcher(reference.pointer) + return _getOnBackInvokedDispatcher(reference.pointer, + _id_getOnBackInvokedDispatcher as jni.JMethodIDPtr) .object(const jni.JObjectType()); } } @@ -14919,78 +21906,127 @@ class Instant extends jni.JObject { late final jni.JObjType $type = type; Instant.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r"java/time/Instant"); /// The type which includes information such as the signature of this class. static const type = $InstantType(); - static final _get_EPOCH = - jniLookup>( - "get_Instant__EPOCH") - .asFunction(); + static final _id_EPOCH = _class.staticFieldId( + r"EPOCH", + r"Ljava/time/Instant;", + ); /// from: static public final java.time.Instant EPOCH /// The returned object must be released after use, by calling the [release] method. - static Instant get EPOCH => _get_EPOCH().object(const $InstantType()); + static Instant get EPOCH => _id_EPOCH.get(_class, const $InstantType()); - static final _get_MAX = - jniLookup>( - "get_Instant__MAX") - .asFunction(); + static final _id_MAX = _class.staticFieldId( + r"MAX", + r"Ljava/time/Instant;", + ); /// from: static public final java.time.Instant MAX /// The returned object must be released after use, by calling the [release] method. - static Instant get MAX => _get_MAX().object(const $InstantType()); + static Instant get MAX => _id_MAX.get(_class, const $InstantType()); - static final _get_MIN = - jniLookup>( - "get_Instant__MIN") - .asFunction(); + static final _id_MIN = _class.staticFieldId( + r"MIN", + r"Ljava/time/Instant;", + ); /// from: static public final java.time.Instant MIN /// The returned object must be released after use, by calling the [release] method. - static Instant get MIN => _get_MIN().object(const $InstantType()); + static Instant get MIN => _id_MIN.get(_class, const $InstantType()); - static final _now = - jniLookup>("Instant__now") - .asFunction(); + static final _id_now = _class.staticMethodId( + r"now", + r"()Ljava/time/Instant;", + ); + + static final _now = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: static public java.time.Instant now() /// The returned object must be released after use, by calling the [release] method. static Instant now() { - return _now().object(const $InstantType()); + return _now(_class.reference.pointer, _id_now as jni.JMethodIDPtr) + .object(const $InstantType()); } - static final _now1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Instant__now1") - .asFunction)>(); + static final _id_now1 = _class.staticMethodId( + r"now", + r"(Ljava/time/Clock;)Ljava/time/Instant;", + ); + + static final _now1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public java.time.Instant now(java.time.Clock clock) /// The returned object must be released after use, by calling the [release] method. static Instant now1( jni.JObject clock, ) { - return _now1(clock.reference.pointer).object(const $InstantType()); + return _now1(_class.reference.pointer, _id_now1 as jni.JMethodIDPtr, + clock.reference.pointer) + .object(const $InstantType()); } - static final _ofEpochSecond = - jniLookup>( - "Instant__ofEpochSecond") - .asFunction(); + static final _id_ofEpochSecond = _class.staticMethodId( + r"ofEpochSecond", + r"(J)Ljava/time/Instant;", + ); + + static final _ofEpochSecond = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.VarArgs<(ffi.Int64,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: static public java.time.Instant ofEpochSecond(long j) /// The returned object must be released after use, by calling the [release] method. static Instant ofEpochSecond( int j, ) { - return _ofEpochSecond(j).object(const $InstantType()); + return _ofEpochSecond( + _class.reference.pointer, _id_ofEpochSecond as jni.JMethodIDPtr, j) + .object(const $InstantType()); } - static final _ofEpochSecond1 = jniLookup< - ffi.NativeFunction>( - "Instant__ofEpochSecond1") - .asFunction(); + static final _id_ofEpochSecond1 = _class.staticMethodId( + r"ofEpochSecond", + r"(JJ)Ljava/time/Instant;", + ); + + static final _ofEpochSecond1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.VarArgs<(ffi.Int64, ffi.Int64)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int, int)>(); /// from: static public java.time.Instant ofEpochSecond(long j, long j1) /// The returned object must be released after use, by calling the [release] method. @@ -14998,174 +22034,302 @@ class Instant extends jni.JObject { int j, int j1, ) { - return _ofEpochSecond1(j, j1).object(const $InstantType()); + return _ofEpochSecond1(_class.reference.pointer, + _id_ofEpochSecond1 as jni.JMethodIDPtr, j, j1) + .object(const $InstantType()); } - static final _ofEpochMilli = - jniLookup>( - "Instant__ofEpochMilli") - .asFunction(); + static final _id_ofEpochMilli = _class.staticMethodId( + r"ofEpochMilli", + r"(J)Ljava/time/Instant;", + ); + + static final _ofEpochMilli = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.VarArgs<(ffi.Int64,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: static public java.time.Instant ofEpochMilli(long j) /// The returned object must be released after use, by calling the [release] method. static Instant ofEpochMilli( int j, ) { - return _ofEpochMilli(j).object(const $InstantType()); + return _ofEpochMilli( + _class.reference.pointer, _id_ofEpochMilli as jni.JMethodIDPtr, j) + .object(const $InstantType()); } - static final _from = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Instant__from") - .asFunction)>(); + static final _id_from = _class.staticMethodId( + r"from", + r"(Ljava/time/temporal/TemporalAccessor;)Ljava/time/Instant;", + ); + + static final _from = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public java.time.Instant from(java.time.temporal.TemporalAccessor temporalAccessor) /// The returned object must be released after use, by calling the [release] method. static Instant from( jni.JObject temporalAccessor, ) { - return _from(temporalAccessor.reference.pointer) + return _from(_class.reference.pointer, _id_from as jni.JMethodIDPtr, + temporalAccessor.reference.pointer) .object(const $InstantType()); } - static final _parse = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer)>>("Instant__parse") - .asFunction)>(); + static final _id_parse = _class.staticMethodId( + r"parse", + r"(Ljava/lang/CharSequence;)Ljava/time/Instant;", + ); + + static final _parse = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public java.time.Instant parse(java.lang.CharSequence charSequence) /// The returned object must be released after use, by calling the [release] method. static Instant parse( jni.JObject charSequence, ) { - return _parse(charSequence.reference.pointer).object(const $InstantType()); + return _parse(_class.reference.pointer, _id_parse as jni.JMethodIDPtr, + charSequence.reference.pointer) + .object(const $InstantType()); } - static final _isSupported = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__isSupported") + static final _id_isSupported = _class.instanceMethodId( + r"isSupported", + r"(Ljava/time/temporal/TemporalField;)Z", + ); + + static final _isSupported = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean isSupported(java.time.temporal.TemporalField temporalField) bool isSupported( jni.JObject temporalField, ) { - return _isSupported(reference.pointer, temporalField.reference.pointer) + return _isSupported(reference.pointer, _id_isSupported as jni.JMethodIDPtr, + temporalField.reference.pointer) .boolean; } - static final _isSupported1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__isSupported1") + static final _id_isSupported1 = _class.instanceMethodId( + r"isSupported", + r"(Ljava/time/temporal/TemporalUnit;)Z", + ); + + static final _isSupported1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean isSupported(java.time.temporal.TemporalUnit temporalUnit) bool isSupported1( jni.JObject temporalUnit, ) { - return _isSupported1(reference.pointer, temporalUnit.reference.pointer) + return _isSupported1( + reference.pointer, + _id_isSupported1 as jni.JMethodIDPtr, + temporalUnit.reference.pointer) .boolean; } - static final _range = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__range") + static final _id_range = _class.instanceMethodId( + r"range", + r"(Ljava/time/temporal/TemporalField;)Ljava/time/temporal/ValueRange;", + ); + + static final _range = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.temporal.ValueRange range(java.time.temporal.TemporalField temporalField) /// The returned object must be released after use, by calling the [release] method. jni.JObject range( jni.JObject temporalField, ) { - return _range(reference.pointer, temporalField.reference.pointer) + return _range(reference.pointer, _id_range as jni.JMethodIDPtr, + temporalField.reference.pointer) .object(const jni.JObjectType()); } - static final _get0 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__get0") + static final _id_get0 = _class.instanceMethodId( + r"get", + r"(Ljava/time/temporal/TemporalField;)I", + ); + + static final _get0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public int get(java.time.temporal.TemporalField temporalField) int get0( jni.JObject temporalField, ) { - return _get0(reference.pointer, temporalField.reference.pointer).integer; + return _get0(reference.pointer, _id_get0 as jni.JMethodIDPtr, + temporalField.reference.pointer) + .integer; } - static final _getLong = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__getLong") + static final _id_getLong = _class.instanceMethodId( + r"getLong", + r"(Ljava/time/temporal/TemporalField;)J", + ); + + static final _getLong = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallLongMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public long getLong(java.time.temporal.TemporalField temporalField) int getLong( jni.JObject temporalField, ) { - return _getLong(reference.pointer, temporalField.reference.pointer).long; + return _getLong(reference.pointer, _id_getLong as jni.JMethodIDPtr, + temporalField.reference.pointer) + .long; } - static final _getEpochSecond = jniLookup< - ffi - .NativeFunction)>>( - "Instant__getEpochSecond") - .asFunction)>(); + static final _id_getEpochSecond = _class.instanceMethodId( + r"getEpochSecond", + r"()J", + ); + + static final _getEpochSecond = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallLongMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public long getEpochSecond() int getEpochSecond() { - return _getEpochSecond(reference.pointer).long; + return _getEpochSecond( + reference.pointer, _id_getEpochSecond as jni.JMethodIDPtr) + .long; } - static final _getNano = jniLookup< - ffi - .NativeFunction)>>( - "Instant__getNano") - .asFunction)>(); + static final _id_getNano = _class.instanceMethodId( + r"getNano", + r"()I", + ); + + static final _getNano = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int getNano() int getNano() { - return _getNano(reference.pointer).integer; + return _getNano(reference.pointer, _id_getNano as jni.JMethodIDPtr).integer; } - static final _with0 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__with0") + static final _id_with0 = _class.instanceMethodId( + r"with", + r"(Ljava/time/temporal/TemporalAdjuster;)Ljava/time/Instant;", + ); + + static final _with0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.Instant with(java.time.temporal.TemporalAdjuster temporalAdjuster) /// The returned object must be released after use, by calling the [release] method. Instant with0( jni.JObject temporalAdjuster, ) { - return _with0(reference.pointer, temporalAdjuster.reference.pointer) + return _with0(reference.pointer, _id_with0 as jni.JMethodIDPtr, + temporalAdjuster.reference.pointer) .object(const $InstantType()); } - static final _with1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int64)>>("Instant__with1") + static final _id_with1 = _class.instanceMethodId( + r"with", + r"(Ljava/time/temporal/TemporalField;J)Ljava/time/Instant;", + ); + + static final _with1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public java.time.Instant with(java.time.temporal.TemporalField temporalField, long j) /// The returned object must be released after use, by calling the [release] method. @@ -15173,51 +22337,78 @@ class Instant extends jni.JObject { jni.JObject temporalField, int j, ) { - return _with1(reference.pointer, temporalField.reference.pointer, j) + return _with1(reference.pointer, _id_with1 as jni.JMethodIDPtr, + temporalField.reference.pointer, j) .object(const $InstantType()); } - static final _truncatedTo = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__truncatedTo") + static final _id_truncatedTo = _class.instanceMethodId( + r"truncatedTo", + r"(Ljava/time/temporal/TemporalUnit;)Ljava/time/Instant;", + ); + + static final _truncatedTo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.Instant truncatedTo(java.time.temporal.TemporalUnit temporalUnit) /// The returned object must be released after use, by calling the [release] method. Instant truncatedTo( jni.JObject temporalUnit, ) { - return _truncatedTo(reference.pointer, temporalUnit.reference.pointer) + return _truncatedTo(reference.pointer, _id_truncatedTo as jni.JMethodIDPtr, + temporalUnit.reference.pointer) .object(const $InstantType()); } - static final _plus = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__plus") + static final _id_plus = _class.instanceMethodId( + r"plus", + r"(Ljava/time/temporal/TemporalAmount;)Ljava/time/Instant;", + ); + + static final _plus = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.Instant plus(java.time.temporal.TemporalAmount temporalAmount) /// The returned object must be released after use, by calling the [release] method. Instant plus( jni.JObject temporalAmount, ) { - return _plus(reference.pointer, temporalAmount.reference.pointer) + return _plus(reference.pointer, _id_plus as jni.JMethodIDPtr, + temporalAmount.reference.pointer) .object(const $InstantType()); } - static final _plus1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int64, - ffi.Pointer)>>("Instant__plus1") + static final _id_plus1 = _class.instanceMethodId( + r"plus", + r"(JLjava/time/temporal/TemporalUnit;)Ljava/time/Instant;", + ); + + static final _plus1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public java.time.Instant plus(long j, java.time.temporal.TemporalUnit temporalUnit) /// The returned object must be released after use, by calling the [release] method. @@ -15225,76 +22416,119 @@ class Instant extends jni.JObject { int j, jni.JObject temporalUnit, ) { - return _plus1(reference.pointer, j, temporalUnit.reference.pointer) + return _plus1(reference.pointer, _id_plus1 as jni.JMethodIDPtr, j, + temporalUnit.reference.pointer) .object(const $InstantType()); } - static final _plusSeconds = jniLookup< + static final _id_plusSeconds = _class.instanceMethodId( + r"plusSeconds", + r"(J)Ljava/time/Instant;", + ); + + static final _plusSeconds = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int64)>>("Instant__plusSeconds") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public java.time.Instant plusSeconds(long j) /// The returned object must be released after use, by calling the [release] method. Instant plusSeconds( int j, ) { - return _plusSeconds(reference.pointer, j).object(const $InstantType()); + return _plusSeconds( + reference.pointer, _id_plusSeconds as jni.JMethodIDPtr, j) + .object(const $InstantType()); } - static final _plusMillis = jniLookup< + static final _id_plusMillis = _class.instanceMethodId( + r"plusMillis", + r"(J)Ljava/time/Instant;", + ); + + static final _plusMillis = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int64)>>("Instant__plusMillis") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public java.time.Instant plusMillis(long j) /// The returned object must be released after use, by calling the [release] method. Instant plusMillis( int j, ) { - return _plusMillis(reference.pointer, j).object(const $InstantType()); + return _plusMillis(reference.pointer, _id_plusMillis as jni.JMethodIDPtr, j) + .object(const $InstantType()); } - static final _plusNanos = jniLookup< + static final _id_plusNanos = _class.instanceMethodId( + r"plusNanos", + r"(J)Ljava/time/Instant;", + ); + + static final _plusNanos = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int64)>>("Instant__plusNanos") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public java.time.Instant plusNanos(long j) /// The returned object must be released after use, by calling the [release] method. Instant plusNanos( int j, ) { - return _plusNanos(reference.pointer, j).object(const $InstantType()); + return _plusNanos(reference.pointer, _id_plusNanos as jni.JMethodIDPtr, j) + .object(const $InstantType()); } - static final _minus = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__minus") + static final _id_minus = _class.instanceMethodId( + r"minus", + r"(Ljava/time/temporal/TemporalAmount;)Ljava/time/Instant;", + ); + + static final _minus = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.Instant minus(java.time.temporal.TemporalAmount temporalAmount) /// The returned object must be released after use, by calling the [release] method. Instant minus( jni.JObject temporalAmount, ) { - return _minus(reference.pointer, temporalAmount.reference.pointer) + return _minus(reference.pointer, _id_minus as jni.JMethodIDPtr, + temporalAmount.reference.pointer) .object(const $InstantType()); } - static final _minus1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int64, - ffi.Pointer)>>("Instant__minus1") + static final _id_minus1 = _class.instanceMethodId( + r"minus", + r"(JLjava/time/temporal/TemporalUnit;)Ljava/time/Instant;", + ); + + static final _minus1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public java.time.Instant minus(long j, java.time.temporal.TemporalUnit temporalUnit) /// The returned object must be released after use, by calling the [release] method. @@ -15302,59 +22536,94 @@ class Instant extends jni.JObject { int j, jni.JObject temporalUnit, ) { - return _minus1(reference.pointer, j, temporalUnit.reference.pointer) + return _minus1(reference.pointer, _id_minus1 as jni.JMethodIDPtr, j, + temporalUnit.reference.pointer) .object(const $InstantType()); } - static final _minusSeconds = jniLookup< + static final _id_minusSeconds = _class.instanceMethodId( + r"minusSeconds", + r"(J)Ljava/time/Instant;", + ); + + static final _minusSeconds = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int64)>>("Instant__minusSeconds") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public java.time.Instant minusSeconds(long j) /// The returned object must be released after use, by calling the [release] method. Instant minusSeconds( int j, ) { - return _minusSeconds(reference.pointer, j).object(const $InstantType()); + return _minusSeconds( + reference.pointer, _id_minusSeconds as jni.JMethodIDPtr, j) + .object(const $InstantType()); } - static final _minusMillis = jniLookup< + static final _id_minusMillis = _class.instanceMethodId( + r"minusMillis", + r"(J)Ljava/time/Instant;", + ); + + static final _minusMillis = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int64)>>("Instant__minusMillis") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public java.time.Instant minusMillis(long j) /// The returned object must be released after use, by calling the [release] method. Instant minusMillis( int j, ) { - return _minusMillis(reference.pointer, j).object(const $InstantType()); + return _minusMillis( + reference.pointer, _id_minusMillis as jni.JMethodIDPtr, j) + .object(const $InstantType()); } - static final _minusNanos = jniLookup< + static final _id_minusNanos = _class.instanceMethodId( + r"minusNanos", + r"(J)Ljava/time/Instant;", + ); + + static final _minusNanos = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Int64)>>("Instant__minusNanos") - .asFunction, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64,)>)>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); /// from: public java.time.Instant minusNanos(long j) /// The returned object must be released after use, by calling the [release] method. Instant minusNanos( int j, ) { - return _minusNanos(reference.pointer, j).object(const $InstantType()); + return _minusNanos(reference.pointer, _id_minusNanos as jni.JMethodIDPtr, j) + .object(const $InstantType()); } - static final _query = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__query") + static final _id_query = _class.instanceMethodId( + r"query", + r"(Ljava/time/temporal/TemporalQuery;)Ljava/lang/Object;", + ); + + static final _query = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public R query(java.time.temporal.TemporalQuery temporalQuery) /// The returned object must be released after use, by calling the [release] method. @@ -15362,181 +22631,304 @@ class Instant extends jni.JObject { jni.JObject temporalQuery, { required jni.JObjType<$R> R, }) { - return _query(reference.pointer, temporalQuery.reference.pointer).object(R); + return _query(reference.pointer, _id_query as jni.JMethodIDPtr, + temporalQuery.reference.pointer) + .object(R); } - static final _adjustInto = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__adjustInto") + static final _id_adjustInto = _class.instanceMethodId( + r"adjustInto", + r"(Ljava/time/temporal/Temporal;)Ljava/time/temporal/Temporal;", + ); + + static final _adjustInto = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.temporal.Temporal adjustInto(java.time.temporal.Temporal temporal) /// The returned object must be released after use, by calling the [release] method. jni.JObject adjustInto( jni.JObject temporal, ) { - return _adjustInto(reference.pointer, temporal.reference.pointer) + return _adjustInto(reference.pointer, _id_adjustInto as jni.JMethodIDPtr, + temporal.reference.pointer) .object(const jni.JObjectType()); } - static final _until = jniLookup< + static final _id_until = _class.instanceMethodId( + r"until", + r"(Ljava/time/temporal/Temporal;Ljava/time/temporal/TemporalUnit;)J", + ); + + static final _until = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("Instant__until") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_CallLongMethod") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); /// from: public long until(java.time.temporal.Temporal temporal, java.time.temporal.TemporalUnit temporalUnit) int until( jni.JObject temporal, jni.JObject temporalUnit, ) { - return _until(reference.pointer, temporal.reference.pointer, - temporalUnit.reference.pointer) + return _until(reference.pointer, _id_until as jni.JMethodIDPtr, + temporal.reference.pointer, temporalUnit.reference.pointer) .long; } - static final _atOffset = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__atOffset") + static final _id_atOffset = _class.instanceMethodId( + r"atOffset", + r"(Ljava/time/ZoneOffset;)Ljava/time/OffsetDateTime;", + ); + + static final _atOffset = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.OffsetDateTime atOffset(java.time.ZoneOffset zoneOffset) /// The returned object must be released after use, by calling the [release] method. jni.JObject atOffset( jni.JObject zoneOffset, ) { - return _atOffset(reference.pointer, zoneOffset.reference.pointer) + return _atOffset(reference.pointer, _id_atOffset as jni.JMethodIDPtr, + zoneOffset.reference.pointer) .object(const jni.JObjectType()); } - static final _atZone = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__atZone") + static final _id_atZone = _class.instanceMethodId( + r"atZone", + r"(Ljava/time/ZoneId;)Ljava/time/ZonedDateTime;", + ); + + static final _atZone = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.ZonedDateTime atZone(java.time.ZoneId zoneId) /// The returned object must be released after use, by calling the [release] method. jni.JObject atZone( jni.JObject zoneId, ) { - return _atZone(reference.pointer, zoneId.reference.pointer) + return _atZone(reference.pointer, _id_atZone as jni.JMethodIDPtr, + zoneId.reference.pointer) .object(const jni.JObjectType()); } - static final _toEpochMilli = jniLookup< - ffi - .NativeFunction)>>( - "Instant__toEpochMilli") - .asFunction)>(); + static final _id_toEpochMilli = _class.instanceMethodId( + r"toEpochMilli", + r"()J", + ); + + static final _toEpochMilli = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallLongMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public long toEpochMilli() int toEpochMilli() { - return _toEpochMilli(reference.pointer).long; + return _toEpochMilli( + reference.pointer, _id_toEpochMilli as jni.JMethodIDPtr) + .long; } - static final _compareTo = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__compareTo") + static final _id_compareTo = _class.instanceMethodId( + r"compareTo", + r"(Ljava/time/Instant;)I", + ); + + static final _compareTo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public int compareTo(java.time.Instant instant) int compareTo( Instant instant, ) { - return _compareTo(reference.pointer, instant.reference.pointer).integer; + return _compareTo(reference.pointer, _id_compareTo as jni.JMethodIDPtr, + instant.reference.pointer) + .integer; } - static final _isAfter = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__isAfter") + static final _id_isAfter = _class.instanceMethodId( + r"isAfter", + r"(Ljava/time/Instant;)Z", + ); + + static final _isAfter = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean isAfter(java.time.Instant instant) bool isAfter( Instant instant, ) { - return _isAfter(reference.pointer, instant.reference.pointer).boolean; + return _isAfter(reference.pointer, _id_isAfter as jni.JMethodIDPtr, + instant.reference.pointer) + .boolean; } - static final _isBefore = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__isBefore") + static final _id_isBefore = _class.instanceMethodId( + r"isBefore", + r"(Ljava/time/Instant;)Z", + ); + + static final _isBefore = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean isBefore(java.time.Instant instant) bool isBefore( Instant instant, ) { - return _isBefore(reference.pointer, instant.reference.pointer).boolean; + return _isBefore(reference.pointer, _id_isBefore as jni.JMethodIDPtr, + instant.reference.pointer) + .boolean; } - static final _equals = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__equals") + static final _id_equals = _class.instanceMethodId( + r"equals", + r"(Ljava/lang/Object;)Z", + ); + + static final _equals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean equals(java.lang.Object object) bool equals( jni.JObject object, ) { - return _equals(reference.pointer, object.reference.pointer).boolean; + return _equals(reference.pointer, _id_equals as jni.JMethodIDPtr, + object.reference.pointer) + .boolean; } - static final _hashCode1 = jniLookup< - ffi - .NativeFunction)>>( - "Instant__hashCode1") - .asFunction)>(); + static final _id_hashCode1 = _class.instanceMethodId( + r"hashCode", + r"()I", + ); + + static final _hashCode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int hashCode() int hashCode1() { - return _hashCode1(reference.pointer).integer; + return _hashCode1(reference.pointer, _id_hashCode1 as jni.JMethodIDPtr) + .integer; } - static final _toString1 = jniLookup< - ffi - .NativeFunction)>>( - "Instant__toString1") - .asFunction)>(); + static final _id_toString1 = _class.instanceMethodId( + r"toString", + r"()Ljava/lang/String;", + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public java.lang.String toString() /// The returned object must be released after use, by calling the [release] method. jni.JString toString1() { - return _toString1(reference.pointer).object(const jni.JStringType()); + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); } - static final _minus2 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int64, - ffi.Pointer)>>("Instant__minus2") + static final _id_minus2 = _class.instanceMethodId( + r"minus", + r"(JLjava/time/temporal/TemporalUnit;)Ljava/time/temporal/Temporal;", + ); + + static final _minus2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public java.time.temporal.Temporal minus(long j, java.time.temporal.TemporalUnit temporalUnit) /// The returned object must be released after use, by calling the [release] method. @@ -15544,34 +22936,52 @@ class Instant extends jni.JObject { int j, jni.JObject temporalUnit, ) { - return _minus2(reference.pointer, j, temporalUnit.reference.pointer) + return _minus2(reference.pointer, _id_minus2 as jni.JMethodIDPtr, j, + temporalUnit.reference.pointer) .object(const jni.JObjectType()); } - static final _minus3 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__minus3") + static final _id_minus3 = _class.instanceMethodId( + r"minus", + r"(Ljava/time/temporal/TemporalAmount;)Ljava/time/temporal/Temporal;", + ); + + static final _minus3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.temporal.Temporal minus(java.time.temporal.TemporalAmount temporalAmount) /// The returned object must be released after use, by calling the [release] method. jni.JObject minus3( jni.JObject temporalAmount, ) { - return _minus3(reference.pointer, temporalAmount.reference.pointer) + return _minus3(reference.pointer, _id_minus3 as jni.JMethodIDPtr, + temporalAmount.reference.pointer) .object(const jni.JObjectType()); } - static final _plus2 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, ffi.Int64, - ffi.Pointer)>>("Instant__plus2") + static final _id_plus2 = _class.instanceMethodId( + r"plus", + r"(JLjava/time/temporal/TemporalUnit;)Ljava/time/temporal/Temporal;", + ); + + static final _plus2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Int64, ffi.Pointer)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); /// from: public java.time.temporal.Temporal plus(long j, java.time.temporal.TemporalUnit temporalUnit) /// The returned object must be released after use, by calling the [release] method. @@ -15579,34 +22989,52 @@ class Instant extends jni.JObject { int j, jni.JObject temporalUnit, ) { - return _plus2(reference.pointer, j, temporalUnit.reference.pointer) + return _plus2(reference.pointer, _id_plus2 as jni.JMethodIDPtr, j, + temporalUnit.reference.pointer) .object(const jni.JObjectType()); } - static final _plus3 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__plus3") + static final _id_plus3 = _class.instanceMethodId( + r"plus", + r"(Ljava/time/temporal/TemporalAmount;)Ljava/time/temporal/Temporal;", + ); + + static final _plus3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.temporal.Temporal plus(java.time.temporal.TemporalAmount temporalAmount) /// The returned object must be released after use, by calling the [release] method. jni.JObject plus3( jni.JObject temporalAmount, ) { - return _plus3(reference.pointer, temporalAmount.reference.pointer) + return _plus3(reference.pointer, _id_plus3 as jni.JMethodIDPtr, + temporalAmount.reference.pointer) .object(const jni.JObjectType()); } - static final _with2 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer, ffi.Int64)>>("Instant__with2") + static final _id_with2 = _class.instanceMethodId( + r"with", + r"(Ljava/time/temporal/TemporalField;J)Ljava/time/temporal/Temporal;", + ); + + static final _with2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Int64)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer, int)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); /// from: public java.time.temporal.Temporal with(java.time.temporal.TemporalField temporalField, long j) /// The returned object must be released after use, by calling the [release] method. @@ -15614,40 +23042,60 @@ class Instant extends jni.JObject { jni.JObject temporalField, int j, ) { - return _with2(reference.pointer, temporalField.reference.pointer, j) + return _with2(reference.pointer, _id_with2 as jni.JMethodIDPtr, + temporalField.reference.pointer, j) .object(const jni.JObjectType()); } - static final _with3 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__with3") + static final _id_with3 = _class.instanceMethodId( + r"with", + r"(Ljava/time/temporal/TemporalAdjuster;)Ljava/time/temporal/Temporal;", + ); + + static final _with3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public java.time.temporal.Temporal with(java.time.temporal.TemporalAdjuster temporalAdjuster) /// The returned object must be released after use, by calling the [release] method. jni.JObject with3( jni.JObject temporalAdjuster, ) { - return _with3(reference.pointer, temporalAdjuster.reference.pointer) + return _with3(reference.pointer, _id_with3 as jni.JMethodIDPtr, + temporalAdjuster.reference.pointer) .object(const jni.JObjectType()); } - static final _compareTo1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("Instant__compareTo1") + static final _id_compareTo1 = _class.instanceMethodId( + r"compareTo", + r"(Ljava/lang/Object;)I", + ); + + static final _compareTo1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallIntMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public int compareTo(java.lang.Object object) int compareTo1( jni.JObject object, ) { - return _compareTo1(reference.pointer, object.reference.pointer).integer; + return _compareTo1(reference.pointer, _id_compareTo1 as jni.JMethodIDPtr, + object.reference.pointer) + .integer; } } @@ -15682,22 +23130,38 @@ class AggregateGroupByDurationRequest extends jni.JObject { late final jni.JObjType $type = type; AggregateGroupByDurationRequest.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/request/AggregateGroupByDurationRequest"); /// The type which includes information such as the signature of this class. static const type = $AggregateGroupByDurationRequestType(); - static final _new0 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>( - "AggregateGroupByDurationRequest__new0") + static final _id_new0 = _class.constructorId( + r"(Ljava/util/Set;Landroidx/health/connect/client/time/TimeRangeFilter;Ljava/time/Duration;Ljava/util/Set;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public void (java.util.Set set, androidx.health.connect.client.time.TimeRangeFilter timeRangeFilter, java.time.Duration duration, java.util.Set set1) /// The returned object must be released after use, by calling the [release] method. @@ -15708,6 +23172,8 @@ class AggregateGroupByDurationRequest extends jni.JObject { jni.JSet set1, ) { return AggregateGroupByDurationRequest.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, set0.reference.pointer, timeRangeFilter.reference.pointer, duration.reference.pointer, @@ -15715,18 +23181,28 @@ class AggregateGroupByDurationRequest extends jni.JObject { .reference); } - static final _new1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>( - "AggregateGroupByDurationRequest__new1") + static final _id_new1 = _class.constructorId( + r"(Ljava/util/Set;Landroidx/health/connect/client/time/TimeRangeFilter;Ljava/time/Duration;Ljava/util/Set;ILkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -15745,6 +23221,8 @@ class AggregateGroupByDurationRequest extends jni.JObject { jni.JObject defaultConstructorMarker, ) { return AggregateGroupByDurationRequest.fromReference(_new1( + _class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, set0.reference.pointer, timeRangeFilter.reference.pointer, duration.reference.pointer, @@ -15789,22 +23267,38 @@ class AggregateGroupByPeriodRequest extends jni.JObject { late final jni.JObjType $type = type; AggregateGroupByPeriodRequest.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/request/AggregateGroupByPeriodRequest"); /// The type which includes information such as the signature of this class. static const type = $AggregateGroupByPeriodRequestType(); - static final _new0 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>( - "AggregateGroupByPeriodRequest__new0") + static final _id_new0 = _class.constructorId( + r"(Ljava/util/Set;Landroidx/health/connect/client/time/TimeRangeFilter;Ljava/time/Period;Ljava/util/Set;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public void (java.util.Set set, androidx.health.connect.client.time.TimeRangeFilter timeRangeFilter, java.time.Period period, java.util.Set set1) /// The returned object must be released after use, by calling the [release] method. @@ -15815,6 +23309,8 @@ class AggregateGroupByPeriodRequest extends jni.JObject { jni.JSet set1, ) { return AggregateGroupByPeriodRequest.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, set0.reference.pointer, timeRangeFilter.reference.pointer, period.reference.pointer, @@ -15822,18 +23318,28 @@ class AggregateGroupByPeriodRequest extends jni.JObject { .reference); } - static final _new1 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>( - "AggregateGroupByPeriodRequest__new1") + static final _id_new1 = _class.constructorId( + r"(Ljava/util/Set;Landroidx/health/connect/client/time/TimeRangeFilter;Ljava/time/Period;Ljava/util/Set;ILkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -15852,6 +23358,8 @@ class AggregateGroupByPeriodRequest extends jni.JObject { jni.JObject defaultConstructorMarker, ) { return AggregateGroupByPeriodRequest.fromReference(_new1( + _class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, set0.reference.pointer, timeRangeFilter.reference.pointer, period.reference.pointer, @@ -15896,19 +23404,35 @@ class AggregateRequest extends jni.JObject { late final jni.JObjType $type = type; AggregateRequest.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/request/AggregateRequest"); /// The type which includes information such as the signature of this class. static const type = $AggregateRequestType(); - static final _new0 = jniLookup< + static final _id_new0 = _class.constructorId( + r"(Ljava/util/Set;Landroidx/health/connect/client/time/TimeRangeFilter;Ljava/util/Set;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("AggregateRequest__new0") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); /// from: public void (java.util.Set set, androidx.health.connect.client.time.TimeRangeFilter timeRangeFilter, java.util.Set set1) @@ -15918,22 +23442,41 @@ class AggregateRequest extends jni.JObject { TimeRangeFilter timeRangeFilter, jni.JSet set1, ) { - return AggregateRequest.fromReference(_new0(set0.reference.pointer, - timeRangeFilter.reference.pointer, set1.reference.pointer) + return AggregateRequest.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + set0.reference.pointer, + timeRangeFilter.reference.pointer, + set1.reference.pointer) .reference); } - static final _new1 = jniLookup< + static final _id_new1 = _class.constructorId( + r"(Ljava/util/Set;Landroidx/health/connect/client/time/TimeRangeFilter;Ljava/util/Set;ILkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("AggregateRequest__new1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); /// from: public void (java.util.Set set, androidx.health.connect.client.time.TimeRangeFilter timeRangeFilter, java.util.Set set1, int i, kotlin.jvm.internal.DefaultConstructorMarker defaultConstructorMarker) /// The returned object must be released after use, by calling the [release] method. @@ -15945,6 +23488,8 @@ class AggregateRequest extends jni.JObject { jni.JObject defaultConstructorMarker, ) { return AggregateRequest.fromReference(_new1( + _class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, set0.reference.pointer, timeRangeFilter.reference.pointer, set1.reference.pointer, @@ -15987,17 +23532,30 @@ class ChangesTokenRequest extends jni.JObject { late final jni.JObjType $type = type; ChangesTokenRequest.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/request/ChangesTokenRequest"); /// The type which includes information such as the signature of this class. static const type = $ChangesTokenRequestType(); - static final _new0 = jniLookup< + static final _id_new0 = _class.constructorId( + r"(Ljava/util/Set;Ljava/util/Set;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("ChangesTokenRequest__new0") + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function( + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer)>(); /// from: public void (java.util.Set set, java.util.Set set1) @@ -16006,20 +23564,38 @@ class ChangesTokenRequest extends jni.JObject { jni.JSet set0, jni.JSet set1, ) { - return ChangesTokenRequest.fromReference( - _new0(set0.reference.pointer, set1.reference.pointer).reference); + return ChangesTokenRequest.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + set0.reference.pointer, + set1.reference.pointer) + .reference); } - static final _new1 = jniLookup< + static final _id_new1 = _class.constructorId( + r"(Ljava/util/Set;Ljava/util/Set;ILkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("ChangesTokenRequest__new1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - int, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); /// from: public void (java.util.Set set, java.util.Set set1, int i, kotlin.jvm.internal.DefaultConstructorMarker defaultConstructorMarker) /// The returned object must be released after use, by calling the [release] method. @@ -16030,6 +23606,8 @@ class ChangesTokenRequest extends jni.JObject { jni.JObject defaultConstructorMarker, ) { return ChangesTokenRequest.fromReference(_new1( + _class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, set0.reference.pointer, set1.reference.pointer, i, @@ -16077,6 +23655,9 @@ class ReadRecordsRequest<$T extends jni.JObject> extends jni.JObject { jni.JReference reference, ) : super.fromReference(reference); + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/request/ReadRecordsRequest"); + /// The type which includes information such as the signature of this class. static $ReadRecordsRequestType<$T> type<$T extends jni.JObject>( jni.JObjType<$T> T, @@ -16086,18 +23667,34 @@ class ReadRecordsRequest<$T extends jni.JObject> extends jni.JObject { ); } - static final _new0 = jniLookup< + static final _id_new0 = _class.constructorId( + r"(Lkotlin/reflect/KClass;Landroidx/health/connect/client/time/TimeRangeFilter;Ljava/util/Set;ZILjava/lang/String;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Uint8, - ffi.Int32, - ffi.Pointer)>>("ReadRecordsRequest__new0") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, int, int, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer)>(); /// from: public void (kotlin.reflect.KClass kClass, androidx.health.connect.client.time.TimeRangeFilter timeRangeFilter, java.util.Set set, boolean z, int i, java.lang.String string) /// The returned object must be released after use, by calling the [release] method. @@ -16112,24 +23709,42 @@ class ReadRecordsRequest<$T extends jni.JObject> extends jni.JObject { }) { return ReadRecordsRequest.fromReference( T, - _new0(kClass.reference.pointer, timeRangeFilter.reference.pointer, - set0.reference.pointer, z ? 1 : 0, i, string.reference.pointer) + _new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + kClass.reference.pointer, + timeRangeFilter.reference.pointer, + set0.reference.pointer, + z ? 1 : 0, + i, + string.reference.pointer) .reference); } - static final _new1 = jniLookup< + static final _id_new1 = _class.constructorId( + r"(Lkotlin/reflect/KClass;Landroidx/health/connect/client/time/TimeRangeFilter;Ljava/util/Set;ZILjava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new1 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Uint8, - ffi.Int32, - ffi.Pointer, - ffi.Int32, - ffi.Pointer)>>("ReadRecordsRequest__new1") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int64, + ffi.Int64, + ffi.Pointer, + ffi.Int64, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer, ffi.Pointer, ffi.Pointer, @@ -16155,6 +23770,8 @@ class ReadRecordsRequest<$T extends jni.JObject> extends jni.JObject { return ReadRecordsRequest.fromReference( T, _new1( + _class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, kClass.reference.pointer, timeRangeFilter.reference.pointer, set0.reference.pointer, @@ -16166,30 +23783,52 @@ class ReadRecordsRequest<$T extends jni.JObject> extends jni.JObject { .reference); } - static final _equals = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("ReadRecordsRequest__equals") + static final _id_equals = _class.instanceMethodId( + r"equals", + r"(Ljava/lang/Object;)Z", + ); + + static final _equals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public boolean equals(java.lang.Object object) bool equals( jni.JObject object, ) { - return _equals(reference.pointer, object.reference.pointer).boolean; + return _equals(reference.pointer, _id_equals as jni.JMethodIDPtr, + object.reference.pointer) + .boolean; } - static final _hashCode1 = jniLookup< - ffi - .NativeFunction)>>( - "ReadRecordsRequest__hashCode1") - .asFunction)>(); + static final _id_hashCode1 = _class.instanceMethodId( + r"hashCode", + r"()I", + ); + + static final _hashCode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallIntMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public int hashCode() int hashCode1() { - return _hashCode1(reference.pointer).integer; + return _hashCode1(reference.pointer, _id_hashCode1 as jni.JMethodIDPtr) + .integer; } } @@ -16232,19 +23871,35 @@ class AggregationResult extends jni.JObject { late final jni.JObjType $type = type; AggregationResult.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/aggregate/AggregationResult"); /// The type which includes information such as the signature of this class. static const type = $AggregationResultType(); - static final _new0 = jniLookup< + static final _id_new0 = _class.constructorId( + r"(Ljava/util/Map;Ljava/util/Map;Ljava/util/Set;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("AggregationResult__new0") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); /// from: public void (java.util.Map map, java.util.Map map1, java.util.Set set) @@ -16254,63 +23909,105 @@ class AggregationResult extends jni.JObject { jni.JMap map1, jni.JSet set0, ) { - return AggregationResult.fromReference(_new0(map.reference.pointer, - map1.reference.pointer, set0.reference.pointer) + return AggregationResult.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + map.reference.pointer, + map1.reference.pointer, + set0.reference.pointer) .reference); } - static final _getDataOrigins = jniLookup< - ffi - .NativeFunction)>>( - "AggregationResult__getDataOrigins") - .asFunction)>(); + static final _id_getDataOrigins = _class.instanceMethodId( + r"getDataOrigins", + r"()Ljava/util/Set;", + ); + + static final _getDataOrigins = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final java.util.Set getDataOrigins() /// The returned object must be released after use, by calling the [release] method. jni.JSet getDataOrigins() { - return _getDataOrigins(reference.pointer) + return _getDataOrigins( + reference.pointer, _id_getDataOrigins as jni.JMethodIDPtr) .object(const jni.JSetType(jni.JObjectType())); } - static final _hasMetric = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("AggregationResult__hasMetric") + static final _id_hasMetric = _class.instanceMethodId( + r"hasMetric", + r"(Landroidx/health/connect/client/aggregate/AggregateMetric;)Z", + ); + + static final _hasMetric = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final boolean hasMetric(androidx.health.connect.client.aggregate.AggregateMetric aggregateMetric) bool hasMetric( AggregateMetric aggregateMetric, ) { - return _hasMetric(reference.pointer, aggregateMetric.reference.pointer) + return _hasMetric(reference.pointer, _id_hasMetric as jni.JMethodIDPtr, + aggregateMetric.reference.pointer) .boolean; } - static final _contains = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("AggregationResult__contains") + static final _id_contains = _class.instanceMethodId( + r"contains", + r"(Landroidx/health/connect/client/aggregate/AggregateMetric;)Z", + ); + + static final _contains = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallBooleanMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final boolean contains(androidx.health.connect.client.aggregate.AggregateMetric aggregateMetric) bool contains( AggregateMetric aggregateMetric, ) { - return _contains(reference.pointer, aggregateMetric.reference.pointer) + return _contains(reference.pointer, _id_contains as jni.JMethodIDPtr, + aggregateMetric.reference.pointer) .boolean; } - static final _getMetric = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("AggregationResult__getMetric") + static final _id_getMetric = _class.instanceMethodId( + r"getMetric", + r"(Landroidx/health/connect/client/aggregate/AggregateMetric;)Ljava/lang/Object;", + ); + + static final _getMetric = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final T getMetric(androidx.health.connect.client.aggregate.AggregateMetric aggregateMetric) /// The returned object must be released after use, by calling the [release] method. @@ -16321,17 +24018,26 @@ class AggregationResult extends jni.JObject { T ??= jni.lowestCommonSuperType([ (aggregateMetric.$type as $AggregateMetricType).T, ]) as jni.JObjType<$T>; - return _getMetric(reference.pointer, aggregateMetric.reference.pointer) + return _getMetric(reference.pointer, _id_getMetric as jni.JMethodIDPtr, + aggregateMetric.reference.pointer) .object(T); } - static final _get0 = jniLookup< - ffi.NativeFunction< - jni.JniResult Function(ffi.Pointer, - ffi.Pointer)>>("AggregationResult__get0") + static final _id_get0 = _class.instanceMethodId( + r"get", + r"(Landroidx/health/connect/client/aggregate/AggregateMetric;)Ljava/lang/Object;", + ); + + static final _get0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallObjectMethod") .asFunction< - jni.JniResult Function( - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public final T get(androidx.health.connect.client.aggregate.AggregateMetric aggregateMetric) /// The returned object must be released after use, by calling the [release] method. @@ -16342,7 +24048,8 @@ class AggregationResult extends jni.JObject { T ??= jni.lowestCommonSuperType([ (aggregateMetric.$type as $AggregateMetricType).T, ]) as jni.JObjType<$T>; - return _get0(reference.pointer, aggregateMetric.reference.pointer) + return _get0(reference.pointer, _id_get0 as jni.JMethodIDPtr, + aggregateMetric.reference.pointer) .object(T); } } @@ -16380,108 +24087,146 @@ class AggregateMetric_AggregationType extends jni.JObject { late final jni.JObjType $type = type; AggregateMetric_AggregationType.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/aggregate/AggregateMetric$AggregationType"); /// The type which includes information such as the signature of this class. static const type = $AggregateMetric_AggregationTypeType(); - static final _get_DURATION = - jniLookup>( - "get_AggregateMetric_AggregationType__DURATION") - .asFunction(); + static final _id_DURATION = _class.staticFieldId( + r"DURATION", + r"Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;", + ); /// from: static public final androidx.health.connect.client.aggregate.AggregateMetric$AggregationType DURATION /// The returned object must be released after use, by calling the [release] method. static AggregateMetric_AggregationType get DURATION => - _get_DURATION().object(const $AggregateMetric_AggregationTypeType()); + _id_DURATION.get(_class, const $AggregateMetric_AggregationTypeType()); - static final _get_AVERAGE = - jniLookup>( - "get_AggregateMetric_AggregationType__AVERAGE") - .asFunction(); + static final _id_AVERAGE = _class.staticFieldId( + r"AVERAGE", + r"Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;", + ); /// from: static public final androidx.health.connect.client.aggregate.AggregateMetric$AggregationType AVERAGE /// The returned object must be released after use, by calling the [release] method. static AggregateMetric_AggregationType get AVERAGE => - _get_AVERAGE().object(const $AggregateMetric_AggregationTypeType()); + _id_AVERAGE.get(_class, const $AggregateMetric_AggregationTypeType()); - static final _get_MINIMUM = - jniLookup>( - "get_AggregateMetric_AggregationType__MINIMUM") - .asFunction(); + static final _id_MINIMUM = _class.staticFieldId( + r"MINIMUM", + r"Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;", + ); /// from: static public final androidx.health.connect.client.aggregate.AggregateMetric$AggregationType MINIMUM /// The returned object must be released after use, by calling the [release] method. static AggregateMetric_AggregationType get MINIMUM => - _get_MINIMUM().object(const $AggregateMetric_AggregationTypeType()); + _id_MINIMUM.get(_class, const $AggregateMetric_AggregationTypeType()); - static final _get_MAXIMUM = - jniLookup>( - "get_AggregateMetric_AggregationType__MAXIMUM") - .asFunction(); + static final _id_MAXIMUM = _class.staticFieldId( + r"MAXIMUM", + r"Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;", + ); /// from: static public final androidx.health.connect.client.aggregate.AggregateMetric$AggregationType MAXIMUM /// The returned object must be released after use, by calling the [release] method. static AggregateMetric_AggregationType get MAXIMUM => - _get_MAXIMUM().object(const $AggregateMetric_AggregationTypeType()); + _id_MAXIMUM.get(_class, const $AggregateMetric_AggregationTypeType()); - static final _get_TOTAL = - jniLookup>( - "get_AggregateMetric_AggregationType__TOTAL") - .asFunction(); + static final _id_TOTAL = _class.staticFieldId( + r"TOTAL", + r"Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;", + ); /// from: static public final androidx.health.connect.client.aggregate.AggregateMetric$AggregationType TOTAL /// The returned object must be released after use, by calling the [release] method. static AggregateMetric_AggregationType get TOTAL => - _get_TOTAL().object(const $AggregateMetric_AggregationTypeType()); + _id_TOTAL.get(_class, const $AggregateMetric_AggregationTypeType()); - static final _get_COUNT = - jniLookup>( - "get_AggregateMetric_AggregationType__COUNT") - .asFunction(); + static final _id_COUNT = _class.staticFieldId( + r"COUNT", + r"Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;", + ); /// from: static public final androidx.health.connect.client.aggregate.AggregateMetric$AggregationType COUNT /// The returned object must be released after use, by calling the [release] method. static AggregateMetric_AggregationType get COUNT => - _get_COUNT().object(const $AggregateMetric_AggregationTypeType()); + _id_COUNT.get(_class, const $AggregateMetric_AggregationTypeType()); + + static final _id_getAggregationTypeString = _class.instanceMethodId( + r"getAggregationTypeString", + r"()Ljava/lang/String;", + ); - static final _getAggregationTypeString = jniLookup< - ffi - .NativeFunction)>>( - "AggregateMetric_AggregationType__getAggregationTypeString") - .asFunction)>(); + static final _getAggregationTypeString = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: public final java.lang.String getAggregationTypeString() /// The returned object must be released after use, by calling the [release] method. jni.JString getAggregationTypeString() { - return _getAggregationTypeString(reference.pointer) + return _getAggregationTypeString( + reference.pointer, _id_getAggregationTypeString as jni.JMethodIDPtr) .object(const jni.JStringType()); } - static final _values = - jniLookup>( - "AggregateMetric_AggregationType__values") - .asFunction(); + static final _id_values = _class.staticMethodId( + r"values", + r"()[Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;", + ); + + static final _values = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>("globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); /// from: static public androidx.health.connect.client.aggregate.AggregateMetric$AggregationType[] values() /// The returned object must be released after use, by calling the [release] method. static jni.JArray values() { - return _values() + return _values(_class.reference.pointer, _id_values as jni.JMethodIDPtr) .object(const jni.JArrayType($AggregateMetric_AggregationTypeType())); } - static final _valueOf = jniLookup< - ffi - .NativeFunction)>>( - "AggregateMetric_AggregationType__valueOf") - .asFunction)>(); + static final _id_valueOf = _class.staticMethodId( + r"valueOf", + r"(Ljava/lang/String;)Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;", + ); + + static final _valueOf = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_CallStaticObjectMethod") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: static public androidx.health.connect.client.aggregate.AggregateMetric$AggregationType valueOf(java.lang.String string) /// The returned object must be released after use, by calling the [release] method. static AggregateMetric_AggregationType valueOf( jni.JString string, ) { - return _valueOf(string.reference.pointer) + return _valueOf(_class.reference.pointer, _id_valueOf as jni.JMethodIDPtr, + string.reference.pointer) .object(const $AggregateMetric_AggregationTypeType()); } } @@ -16520,24 +24265,39 @@ class AggregateMetric_Companion extends jni.JObject { late final jni.JObjType $type = type; AggregateMetric_Companion.fromReference( - super.reference, - ) : super.fromReference(); + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/aggregate/AggregateMetric$Companion"); /// The type which includes information such as the signature of this class. static const type = $AggregateMetric_CompanionType(); - static final _new0 = jniLookup< - ffi - .NativeFunction)>>( - "AggregateMetric_Companion__new0") - .asFunction)>(); + static final _id_new0 = _class.constructorId( + r"(Lkotlin/jvm/internal/DefaultConstructorMarker;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + "globalEnv_NewObject") + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); /// from: public void (kotlin.jvm.internal.DefaultConstructorMarker defaultConstructorMarker) /// The returned object must be released after use, by calling the [release] method. factory AggregateMetric_Companion( jni.JObject defaultConstructorMarker, ) { - return AggregateMetric_Companion.fromReference( - _new0(defaultConstructorMarker.reference.pointer).reference); + return AggregateMetric_Companion.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + defaultConstructorMarker.reference.pointer) + .reference); } } @@ -16583,6 +24343,9 @@ class AggregateMetric_Converter_FromDouble<$R extends jni.JObject> jni.JReference reference, ) : super.fromReference(reference); + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/aggregate/AggregateMetric$Converter$FromDouble"); + /// The type which includes information such as the signature of this class. static $AggregateMetric_Converter_FromDoubleType<$R> type<$R extends jni.JObject>( @@ -16643,6 +24406,9 @@ class AggregateMetric_Converter_FromLong<$R extends jni.JObject> jni.JReference reference, ) : super.fromReference(reference); + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/aggregate/AggregateMetric$Converter$FromLong"); + /// The type which includes information such as the signature of this class. static $AggregateMetric_Converter_FromLongType<$R> type<$R extends jni.JObject>( @@ -16703,6 +24469,9 @@ class AggregateMetric_Converter<$T extends jni.JObject, $R extends jni.JObject> jni.JReference reference, ) : super.fromReference(reference); + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/aggregate/AggregateMetric$Converter"); + /// The type which includes information such as the signature of this class. static $AggregateMetric_ConverterType<$T, $R> type<$T extends jni.JObject, $R extends jni.JObject>( @@ -16765,6 +24534,9 @@ class AggregateMetric<$T extends jni.JObject> extends jni.JObject { jni.JReference reference, ) : super.fromReference(reference); + static final _class = jni.JClass.forName( + r"androidx/health/connect/client/aggregate/AggregateMetric"); + /// The type which includes information such as the signature of this class. static $AggregateMetricType<$T> type<$T extends jni.JObject>( jni.JObjType<$T> T, @@ -16774,26 +24546,40 @@ class AggregateMetric<$T extends jni.JObject> extends jni.JObject { ); } - static final _get_Companion = - jniLookup>( - "get_AggregateMetric__Companion") - .asFunction(); + static final _id_Companion = _class.staticFieldId( + r"Companion", + r"Landroidx/health/connect/client/aggregate/AggregateMetric$Companion;", + ); /// from: static public final androidx.health.connect.client.aggregate.AggregateMetric$Companion Companion /// The returned object must be released after use, by calling the [release] method. static AggregateMetric_Companion get Companion => - _get_Companion().object(const $AggregateMetric_CompanionType()); + _id_Companion.get(_class, const $AggregateMetric_CompanionType()); - static final _new0 = jniLookup< + static final _id_new0 = _class.constructorId( + r"(Landroidx/health/connect/client/aggregate/AggregateMetric$Converter;Ljava/lang/String;Landroidx/health/connect/client/aggregate/AggregateMetric$AggregationType;Ljava/lang/String;)V", + ); + + static final _new0 = ProtectedJniExtensions.lookup< ffi.NativeFunction< jni.JniResult Function( ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>("AggregateMetric__new0") + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>("globalEnv_NewObject") .asFunction< - jni.JniResult Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); /// from: public void (androidx.health.connect.client.aggregate.AggregateMetric$Converter converter, java.lang.String string, androidx.health.connect.client.aggregate.AggregateMetric$AggregationType aggregationType, java.lang.String string1) /// The returned object must be released after use, by calling the [release] method. @@ -16809,8 +24595,13 @@ class AggregateMetric<$T extends jni.JObject> extends jni.JObject { ]) as jni.JObjType<$T>; return AggregateMetric.fromReference( T, - _new0(converter.reference.pointer, string.reference.pointer, - aggregationType.reference.pointer, string1.reference.pointer) + _new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + converter.reference.pointer, + string.reference.pointer, + aggregationType.reference.pointer, + string1.reference.pointer) .reference); } } diff --git a/experimental/pedometer/pubspec.yaml b/experimental/pedometer/pubspec.yaml index f9a0684d9dc..a51ca00179a 100644 --- a/experimental/pedometer/pubspec.yaml +++ b/experimental/pedometer/pubspec.yaml @@ -10,15 +10,15 @@ dependencies: flutter: sdk: flutter plugin_platform_interface: ^2.1.8 - jni: ^0.8.0 + jni: ^0.9.0 ffi: ^2.1.2 dev_dependencies: - ffigen: ^11.0.0 - jnigen: ^0.8.0 + ffigen: ^12.0.0 + jnigen: ^0.9.0 flutter_test: sdk: flutter - flutter_lints: ^3.0.0 + flutter_lints: ^4.0.0 # For information on the generic Dart part of this file, see the # following page: https://dart.dev/tools/pub/pubspec diff --git a/game_template/pubspec.yaml b/game_template/pubspec.yaml index f1c64e2d100..2fb6041b4b9 100644 --- a/game_template/pubspec.yaml +++ b/game_template/pubspec.yaml @@ -30,7 +30,7 @@ dependencies: in_app_purchase: ^3.0.1 # In-app purchases dev_dependencies: - flutter_lints: ^3.0.0 + flutter_lints: ^4.0.0 flutter_test: sdk: flutter flutter_launcher_icons: ^0.13.0 diff --git a/gemini_tasks/.gitignore b/gemini_tasks/.gitignore new file mode 100644 index 00000000000..29a3a5017f0 --- /dev/null +++ b/gemini_tasks/.gitignore @@ -0,0 +1,43 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.buildlog/ +.history +.svn/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# The .vscode folder contains launch configuration and tasks you configure in +# VS Code which you may wish to be included in version control, so this line +# is commented out by default. +#.vscode/ + +# Flutter/Dart/Pub related +**/doc/api/ +**/ios/Flutter/.last_build_id +.dart_tool/ +.flutter-plugins +.flutter-plugins-dependencies +.pub-cache/ +.pub/ +/build/ + +# Symbolication related +app.*.symbols + +# Obfuscation related +app.*.map.json + +# Android Studio will place build artifacts here +/android/app/debug +/android/app/profile +/android/app/release diff --git a/gemini_tasks/.metadata b/gemini_tasks/.metadata new file mode 100644 index 00000000000..8629a4e1864 --- /dev/null +++ b/gemini_tasks/.metadata @@ -0,0 +1,45 @@ +# This file tracks properties of this Flutter project. +# Used by Flutter tool to assess capabilities and perform upgrades etc. +# +# This file should be version controlled and should not be manually edited. + +version: + revision: "abb292a07e20d696c4568099f918f6c5f330e6b0" + channel: "stable" + +project_type: app + +# Tracks metadata for the flutter migrate command +migration: + platforms: + - platform: root + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: android + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: ios + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: linux + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: macos + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: web + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + - platform: windows + create_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + base_revision: abb292a07e20d696c4568099f918f6c5f330e6b0 + + # User provided section + + # List of Local paths (relative to this file) that should be + # ignored by the migrate tool. + # + # Files that are not part of the templates will be ignored by default. + unmanaged_files: + - 'lib/main.dart' + - 'ios/Runner.xcodeproj/project.pbxproj' diff --git a/gemini_tasks/CONTRIBUTING.md b/gemini_tasks/CONTRIBUTING.md new file mode 100644 index 00000000000..8956a61b820 --- /dev/null +++ b/gemini_tasks/CONTRIBUTING.md @@ -0,0 +1,32 @@ +# How to Contribute + +We would love to accept your patches and contributions to this project. + +## Before you begin + +### Sign our Contributor License Agreement + +Contributions to this project must be accompanied by a +[Contributor License Agreement](https://cla.developers.google.com/about) (CLA). +You (or your employer) retain the copyright to your contribution; this simply +gives us permission to use and redistribute your contributions as part of the +project. + +If you or your current employer have already signed the Google CLA (even if it +was for a different project), you probably don't need to do it again. + +Visit to see your current agreements or to +sign a new one. + +### Review our Community Guidelines + +This project follows [Google's Open Source Community +Guidelines](https://opensource.google/conduct/). + +## Contribution process + +### Code Reviews + +All submissions, including submissions by project members, require review. We +use [GitHub pull requests](https://docs.github.com/articles/about-pull-requests) +for this purpose. diff --git a/gemini_tasks/LICENSE b/gemini_tasks/LICENSE new file mode 100644 index 00000000000..7a4a3ea2424 --- /dev/null +++ b/gemini_tasks/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/gemini_tasks/analysis_options.yaml b/gemini_tasks/analysis_options.yaml new file mode 100644 index 00000000000..0d2902135ca --- /dev/null +++ b/gemini_tasks/analysis_options.yaml @@ -0,0 +1,28 @@ +# This file configures the analyzer, which statically analyzes Dart code to +# check for errors, warnings, and lints. +# +# The issues identified by the analyzer are surfaced in the UI of Dart-enabled +# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be +# invoked from the command line by running `flutter analyze`. + +# The following line activates a set of recommended lints for Flutter apps, +# packages, and plugins designed to encourage good coding practices. +include: package:flutter_lints/flutter.yaml + +linter: + # The lint rules applied to this project can be customized in the + # section below to disable rules from the `package:flutter_lints/flutter.yaml` + # included above or to enable additional rules. A list of all available lints + # and their documentation is published at https://dart.dev/lints. + # + # Instead of disabling a lint rule for the entire project in the + # section below, it can also be suppressed for a single line of code + # or a specific dart file by using the `// ignore: name_of_lint` and + # `// ignore_for_file: name_of_lint` syntax on the line or in the file + # producing the lint. + rules: + # avoid_print: false # Uncomment to disable the `avoid_print` rule + # prefer_single_quotes: true # Uncomment to enable the `prefer_single_quotes` rule + +# Additional information about this file can be found at +# https://dart.dev/guides/language/analysis-options diff --git a/gemini_tasks/android/.gitignore b/gemini_tasks/android/.gitignore new file mode 100644 index 00000000000..6f568019d3c --- /dev/null +++ b/gemini_tasks/android/.gitignore @@ -0,0 +1,13 @@ +gradle-wrapper.jar +/.gradle +/captures/ +/gradlew +/gradlew.bat +/local.properties +GeneratedPluginRegistrant.java + +# Remember to never publicly share your keystore. +# See https://flutter.dev/docs/deployment/android#reference-the-keystore-from-the-app +key.properties +**/*.keystore +**/*.jks diff --git a/gemini_tasks/android/app/build.gradle b/gemini_tasks/android/app/build.gradle new file mode 100644 index 00000000000..938b4320637 --- /dev/null +++ b/gemini_tasks/android/app/build.gradle @@ -0,0 +1,67 @@ +plugins { + id "com.android.application" + id "kotlin-android" + id "dev.flutter.flutter-gradle-plugin" +} + +def localProperties = new Properties() +def localPropertiesFile = rootProject.file('local.properties') +if (localPropertiesFile.exists()) { + localPropertiesFile.withReader('UTF-8') { reader -> + localProperties.load(reader) + } +} + +def flutterVersionCode = localProperties.getProperty('flutter.versionCode') +if (flutterVersionCode == null) { + flutterVersionCode = '1' +} + +def flutterVersionName = localProperties.getProperty('flutter.versionName') +if (flutterVersionName == null) { + flutterVersionName = '1.0' +} + +android { + namespace "com.example.gemini_tasks" + compileSdk flutter.compileSdkVersion + ndkVersion flutter.ndkVersion + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + kotlinOptions { + jvmTarget = '1.8' + } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } + + defaultConfig { + // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html). + applicationId "com.example.gemini_tasks" + // You can update the following values to match your application needs. + // For more information, see: https://docs.flutter.dev/deployment/android#reviewing-the-gradle-build-configuration. + minSdkVersion flutter.minSdkVersion + targetSdkVersion flutter.targetSdkVersion + versionCode flutterVersionCode.toInteger() + versionName flutterVersionName + } + + buildTypes { + release { + // TODO: Add your own signing config for the release build. + // Signing with the debug keys for now, so `flutter run --release` works. + signingConfig signingConfigs.debug + } + } +} + +flutter { + source '../..' +} + +dependencies {} diff --git a/gemini_tasks/android/app/src/debug/AndroidManifest.xml b/gemini_tasks/android/app/src/debug/AndroidManifest.xml new file mode 100644 index 00000000000..399f6981d5d --- /dev/null +++ b/gemini_tasks/android/app/src/debug/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/gemini_tasks/android/app/src/main/AndroidManifest.xml b/gemini_tasks/android/app/src/main/AndroidManifest.xml new file mode 100644 index 00000000000..04844322d9d --- /dev/null +++ b/gemini_tasks/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/gemini_tasks/android/app/src/main/kotlin/com/example/gemini_tasks/MainActivity.kt b/gemini_tasks/android/app/src/main/kotlin/com/example/gemini_tasks/MainActivity.kt new file mode 100644 index 00000000000..c2fb91d1653 --- /dev/null +++ b/gemini_tasks/android/app/src/main/kotlin/com/example/gemini_tasks/MainActivity.kt @@ -0,0 +1,5 @@ +package com.example.gemini_tasks + +import io.flutter.embedding.android.FlutterActivity + +class MainActivity: FlutterActivity() diff --git a/gemini_tasks/android/app/src/main/res/drawable-v21/launch_background.xml b/gemini_tasks/android/app/src/main/res/drawable-v21/launch_background.xml new file mode 100644 index 00000000000..f74085f3f6a --- /dev/null +++ b/gemini_tasks/android/app/src/main/res/drawable-v21/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/gemini_tasks/android/app/src/main/res/drawable/launch_background.xml b/gemini_tasks/android/app/src/main/res/drawable/launch_background.xml new file mode 100644 index 00000000000..304732f8842 --- /dev/null +++ b/gemini_tasks/android/app/src/main/res/drawable/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/gemini_tasks/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/gemini_tasks/android/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 00000000000..db77bb4b7b0 Binary files /dev/null and b/gemini_tasks/android/app/src/main/res/mipmap-hdpi/ic_launcher.png differ diff --git a/gemini_tasks/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/gemini_tasks/android/app/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 00000000000..17987b79bb8 Binary files /dev/null and b/gemini_tasks/android/app/src/main/res/mipmap-mdpi/ic_launcher.png differ diff --git a/gemini_tasks/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/gemini_tasks/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png new file mode 100644 index 00000000000..09d4391482b Binary files /dev/null and b/gemini_tasks/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ diff --git a/gemini_tasks/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/gemini_tasks/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 00000000000..d5f1c8d34e7 Binary files /dev/null and b/gemini_tasks/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ diff --git a/gemini_tasks/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/gemini_tasks/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 00000000000..4d6372eebdb Binary files /dev/null and b/gemini_tasks/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ diff --git a/gemini_tasks/android/app/src/main/res/values-night/styles.xml b/gemini_tasks/android/app/src/main/res/values-night/styles.xml new file mode 100644 index 00000000000..06952be745f --- /dev/null +++ b/gemini_tasks/android/app/src/main/res/values-night/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/gemini_tasks/android/app/src/main/res/values/styles.xml b/gemini_tasks/android/app/src/main/res/values/styles.xml new file mode 100644 index 00000000000..cb1ef88056e --- /dev/null +++ b/gemini_tasks/android/app/src/main/res/values/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/gemini_tasks/android/app/src/profile/AndroidManifest.xml b/gemini_tasks/android/app/src/profile/AndroidManifest.xml new file mode 100644 index 00000000000..399f6981d5d --- /dev/null +++ b/gemini_tasks/android/app/src/profile/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/gemini_tasks/android/build.gradle b/gemini_tasks/android/build.gradle new file mode 100644 index 00000000000..bc157bd1a12 --- /dev/null +++ b/gemini_tasks/android/build.gradle @@ -0,0 +1,18 @@ +allprojects { + repositories { + google() + mavenCentral() + } +} + +rootProject.buildDir = '../build' +subprojects { + project.buildDir = "${rootProject.buildDir}/${project.name}" +} +subprojects { + project.evaluationDependsOn(':app') +} + +tasks.register("clean", Delete) { + delete rootProject.buildDir +} diff --git a/gemini_tasks/android/gradle.properties b/gemini_tasks/android/gradle.properties new file mode 100644 index 00000000000..598d13fee44 --- /dev/null +++ b/gemini_tasks/android/gradle.properties @@ -0,0 +1,3 @@ +org.gradle.jvmargs=-Xmx4G +android.useAndroidX=true +android.enableJetifier=true diff --git a/gemini_tasks/android/gradle/wrapper/gradle-wrapper.properties b/gemini_tasks/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000000..e1ca574ef01 --- /dev/null +++ b/gemini_tasks/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.3-all.zip diff --git a/gemini_tasks/android/settings.gradle b/gemini_tasks/android/settings.gradle new file mode 100644 index 00000000000..1d6d19b7f8e --- /dev/null +++ b/gemini_tasks/android/settings.gradle @@ -0,0 +1,26 @@ +pluginManagement { + def flutterSdkPath = { + def properties = new Properties() + file("local.properties").withInputStream { properties.load(it) } + def flutterSdkPath = properties.getProperty("flutter.sdk") + assert flutterSdkPath != null, "flutter.sdk not set in local.properties" + return flutterSdkPath + } + settings.ext.flutterSdkPath = flutterSdkPath() + + includeBuild("${settings.ext.flutterSdkPath}/packages/flutter_tools/gradle") + + repositories { + google() + mavenCentral() + gradlePluginPortal() + } +} + +plugins { + id "dev.flutter.flutter-plugin-loader" version "1.0.0" + id "com.android.application" version "7.3.0" apply false + id "org.jetbrains.kotlin.android" version "1.7.10" apply false +} + +include ":app" diff --git a/gemini_tasks/ios/.gitignore b/gemini_tasks/ios/.gitignore new file mode 100644 index 00000000000..7a7f9873ad7 --- /dev/null +++ b/gemini_tasks/ios/.gitignore @@ -0,0 +1,34 @@ +**/dgph +*.mode1v3 +*.mode2v3 +*.moved-aside +*.pbxuser +*.perspectivev3 +**/*sync/ +.sconsign.dblite +.tags* +**/.vagrant/ +**/DerivedData/ +Icon? +**/Pods/ +**/.symlinks/ +profile +xcuserdata +**/.generated/ +Flutter/App.framework +Flutter/Flutter.framework +Flutter/Flutter.podspec +Flutter/Generated.xcconfig +Flutter/ephemeral/ +Flutter/app.flx +Flutter/app.zip +Flutter/flutter_assets/ +Flutter/flutter_export_environment.sh +ServiceDefinitions.json +Runner/GeneratedPluginRegistrant.* + +# Exceptions to above rules. +!default.mode1v3 +!default.mode2v3 +!default.pbxuser +!default.perspectivev3 diff --git a/gemini_tasks/ios/Flutter/AppFrameworkInfo.plist b/gemini_tasks/ios/Flutter/AppFrameworkInfo.plist new file mode 100644 index 00000000000..7c569640062 --- /dev/null +++ b/gemini_tasks/ios/Flutter/AppFrameworkInfo.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + App + CFBundleIdentifier + io.flutter.flutter.app + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + App + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1.0 + MinimumOSVersion + 12.0 + + diff --git a/gemini_tasks/ios/Flutter/Debug.xcconfig b/gemini_tasks/ios/Flutter/Debug.xcconfig new file mode 100644 index 00000000000..ec97fc6f302 --- /dev/null +++ b/gemini_tasks/ios/Flutter/Debug.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig" +#include "Generated.xcconfig" diff --git a/gemini_tasks/ios/Flutter/Release.xcconfig b/gemini_tasks/ios/Flutter/Release.xcconfig new file mode 100644 index 00000000000..c4855bfe200 --- /dev/null +++ b/gemini_tasks/ios/Flutter/Release.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig" +#include "Generated.xcconfig" diff --git a/gemini_tasks/ios/Podfile b/gemini_tasks/ios/Podfile new file mode 100644 index 00000000000..d97f17e223f --- /dev/null +++ b/gemini_tasks/ios/Podfile @@ -0,0 +1,44 @@ +# Uncomment this line to define a global platform for your project +# platform :ios, '12.0' + +# CocoaPods analytics sends network stats synchronously affecting flutter build latency. +ENV['COCOAPODS_DISABLE_STATS'] = 'true' + +project 'Runner', { + 'Debug' => :debug, + 'Profile' => :release, + 'Release' => :release, +} + +def flutter_root + generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'Generated.xcconfig'), __FILE__) + unless File.exist?(generated_xcode_build_settings_path) + raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure flutter pub get is executed first" + end + + File.foreach(generated_xcode_build_settings_path) do |line| + matches = line.match(/FLUTTER_ROOT\=(.*)/) + return matches[1].strip if matches + end + raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Generated.xcconfig, then run flutter pub get" +end + +require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root) + +flutter_ios_podfile_setup + +target 'Runner' do + use_frameworks! + use_modular_headers! + + flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__)) + target 'RunnerTests' do + inherit! :search_paths + end +end + +post_install do |installer| + installer.pods_project.targets.each do |target| + flutter_additional_ios_build_settings(target) + end +end diff --git a/gemini_tasks/ios/Runner.xcodeproj/project.pbxproj b/gemini_tasks/ios/Runner.xcodeproj/project.pbxproj new file mode 100644 index 00000000000..16e2a3544ee --- /dev/null +++ b/gemini_tasks/ios/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,616 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXBuildFile section */ + 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; }; + 331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; }; + 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; }; + 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; }; + 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; }; + 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; }; + 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C8085294A63A400263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 97C146E61CF9000F007C117D /* Project object */; + proxyType = 1; + remoteGlobalIDString = 97C146ED1CF9000F007C117D; + remoteInfo = Runner; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 9705A1C41CF9048500538489 /* Embed Frameworks */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Embed Frameworks"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = ""; }; + 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = ""; }; + 331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = ""; }; + 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = ""; }; + 74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = ""; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = ""; }; + 9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = ""; }; + 97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; + 97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + 97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; + 97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 97C146EB1CF9000F007C117D /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 331C8082294A63A400263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C807B294A618700263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 9740EEB11CF90186004384FC /* Flutter */ = { + isa = PBXGroup; + children = ( + 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 9740EEB31CF90195004384FC /* Generated.xcconfig */, + ); + name = Flutter; + sourceTree = ""; + }; + 97C146E51CF9000F007C117D = { + isa = PBXGroup; + children = ( + 9740EEB11CF90186004384FC /* Flutter */, + 97C146F01CF9000F007C117D /* Runner */, + 97C146EF1CF9000F007C117D /* Products */, + 331C8082294A63A400263BE5 /* RunnerTests */, + ); + sourceTree = ""; + }; + 97C146EF1CF9000F007C117D /* Products */ = { + isa = PBXGroup; + children = ( + 97C146EE1CF9000F007C117D /* Runner.app */, + 331C8081294A63A400263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 97C146F01CF9000F007C117D /* Runner */ = { + isa = PBXGroup; + children = ( + 97C146FA1CF9000F007C117D /* Main.storyboard */, + 97C146FD1CF9000F007C117D /* Assets.xcassets */, + 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */, + 97C147021CF9000F007C117D /* Info.plist */, + 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */, + 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */, + 74858FAE1ED2DC5600515810 /* AppDelegate.swift */, + 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */, + ); + path = Runner; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C8080294A63A400263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 331C807D294A63A400263BE5 /* Sources */, + 331C807F294A63A400263BE5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 331C8086294A63A400263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C8081294A63A400263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 97C146ED1CF9000F007C117D /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + 9740EEB61CF901F6004384FC /* Run Script */, + 97C146EA1CF9000F007C117D /* Sources */, + 97C146EB1CF9000F007C117D /* Frameworks */, + 97C146EC1CF9000F007C117D /* Resources */, + 9705A1C41CF9048500538489 /* Embed Frameworks */, + 3B06AD1E1E4923F5004D2608 /* Thin Binary */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = Runner; + productName = Runner; + productReference = 97C146EE1CF9000F007C117D /* Runner.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 97C146E61CF9000F007C117D /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C8080294A63A400263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 97C146ED1CF9000F007C117D; + }; + 97C146ED1CF9000F007C117D = { + CreatedOnToolsVersion = 7.3.1; + LastSwiftMigration = 1100; + }; + }; + }; + buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 97C146E51CF9000F007C117D; + productRefGroup = 97C146EF1CF9000F007C117D /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 97C146ED1CF9000F007C117D /* Runner */, + 331C8080294A63A400263BE5 /* RunnerTests */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C807F294A63A400263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EC1CF9000F007C117D /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */, + 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */, + 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */, + 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 3B06AD1E1E4923F5004D2608 /* Thin Binary */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + "${TARGET_BUILD_DIR}/${INFOPLIST_PATH}", + ); + name = "Thin Binary"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin"; + }; + 9740EEB61CF901F6004384FC /* Run Script */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "Run Script"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build"; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C807D294A63A400263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EA1CF9000F007C117D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */, + 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C8086294A63A400263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 97C146ED1CF9000F007C117D /* Runner */; + targetProxy = 331C8085294A63A400263BE5 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 97C146FA1CF9000F007C117D /* Main.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 97C146FB1CF9000F007C117D /* Base */, + ); + name = Main.storyboard; + sourceTree = ""; + }; + 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 97C147001CF9000F007C117D /* Base */, + ); + name = LaunchScreen.storyboard; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 249021D3217E4FDB00AE95B9 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SUPPORTED_PLATFORMS = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Profile; + }; + 249021D4217E4FDB00AE95B9 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Profile; + }; + 331C8088294A63A400263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Debug; + }; + 331C8089294A63A400263BE5 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Release; + }; + 331C808A294A63A400263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Profile; + }; + 97C147031CF9000F007C117D /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 97C147041CF9000F007C117D /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SUPPORTED_PLATFORMS = iphoneos; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 97C147061CF9000F007C117D /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Debug; + }; + 97C147071CF9000F007C117D /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C8088294A63A400263BE5 /* Debug */, + 331C8089294A63A400263BE5 /* Release */, + 331C808A294A63A400263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 97C147031CF9000F007C117D /* Debug */, + 97C147041CF9000F007C117D /* Release */, + 249021D3217E4FDB00AE95B9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 97C147061CF9000F007C117D /* Debug */, + 97C147071CF9000F007C117D /* Release */, + 249021D4217E4FDB00AE95B9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 97C146E61CF9000F007C117D /* Project object */; +} diff --git a/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 00000000000..919434a6254 --- /dev/null +++ b/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings b/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings new file mode 100644 index 00000000000..f9b0d7c5ea1 --- /dev/null +++ b/gemini_tasks/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings @@ -0,0 +1,8 @@ + + + + + PreviewsEnabled + + + diff --git a/gemini_tasks/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/gemini_tasks/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 00000000000..8e3ca5dfe19 --- /dev/null +++ b/gemini_tasks/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gemini_tasks/ios/Runner.xcworkspace/contents.xcworkspacedata b/gemini_tasks/ios/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 00000000000..1d526a16ed0 --- /dev/null +++ b/gemini_tasks/ios/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/gemini_tasks/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/gemini_tasks/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/gemini_tasks/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/gemini_tasks/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings b/gemini_tasks/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings new file mode 100644 index 00000000000..f9b0d7c5ea1 --- /dev/null +++ b/gemini_tasks/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings @@ -0,0 +1,8 @@ + + + + + PreviewsEnabled + + + diff --git a/gemini_tasks/ios/Runner/AppDelegate.swift b/gemini_tasks/ios/Runner/AppDelegate.swift new file mode 100644 index 00000000000..70693e4a8c1 --- /dev/null +++ b/gemini_tasks/ios/Runner/AppDelegate.swift @@ -0,0 +1,13 @@ +import UIKit +import Flutter + +@UIApplicationMain +@objc class AppDelegate: FlutterAppDelegate { + override func application( + _ application: UIApplication, + didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? + ) -> Bool { + GeneratedPluginRegistrant.register(with: self) + return super.application(application, didFinishLaunchingWithOptions: launchOptions) + } +} diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 00000000000..d36b1fab2d9 --- /dev/null +++ b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,122 @@ +{ + "images" : [ + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-App-20x20@2x.png", + "scale" : "2x" + }, + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-App-20x20@3x.png", + "scale" : "3x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@1x.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@3x.png", + "scale" : "3x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-App-40x40@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-App-40x40@3x.png", + "scale" : "3x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-App-60x60@2x.png", + "scale" : "2x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-App-60x60@3x.png", + "scale" : "3x" + }, + { + "size" : "20x20", + "idiom" : "ipad", + "filename" : "Icon-App-20x20@1x.png", + "scale" : "1x" + }, + { + "size" : "20x20", + "idiom" : "ipad", + "filename" : "Icon-App-20x20@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "ipad", + "filename" : "Icon-App-29x29@1x.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "ipad", + "filename" : "Icon-App-29x29@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "ipad", + "filename" : "Icon-App-40x40@1x.png", + "scale" : "1x" + }, + { + "size" : "40x40", + "idiom" : "ipad", + "filename" : "Icon-App-40x40@2x.png", + "scale" : "2x" + }, + { + "size" : "76x76", + "idiom" : "ipad", + "filename" : "Icon-App-76x76@1x.png", + "scale" : "1x" + }, + { + "size" : "76x76", + "idiom" : "ipad", + "filename" : "Icon-App-76x76@2x.png", + "scale" : "2x" + }, + { + "size" : "83.5x83.5", + "idiom" : "ipad", + "filename" : "Icon-App-83.5x83.5@2x.png", + "scale" : "2x" + }, + { + "size" : "1024x1024", + "idiom" : "ios-marketing", + "filename" : "Icon-App-1024x1024@1x.png", + "scale" : "1x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png new file mode 100644 index 00000000000..dc9ada4725e Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png new file mode 100644 index 00000000000..7353c41ecf9 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png new file mode 100644 index 00000000000..797d452e458 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png new file mode 100644 index 00000000000..6ed2d933e11 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png new file mode 100644 index 00000000000..4cd7b0099ca Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png new file mode 100644 index 00000000000..fe730945a01 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png new file mode 100644 index 00000000000..321773cd857 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png new file mode 100644 index 00000000000..797d452e458 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png new file mode 100644 index 00000000000..502f463a9bc Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png new file mode 100644 index 00000000000..0ec30343922 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png new file mode 100644 index 00000000000..0ec30343922 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png new file mode 100644 index 00000000000..e9f5fea27c7 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png new file mode 100644 index 00000000000..84ac32ae7d9 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png new file mode 100644 index 00000000000..8953cba0906 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png new file mode 100644 index 00000000000..0467bf12aa4 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json new file mode 100644 index 00000000000..0bedcf2fd46 --- /dev/null +++ b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json @@ -0,0 +1,23 @@ +{ + "images" : [ + { + "idiom" : "universal", + "filename" : "LaunchImage.png", + "scale" : "1x" + }, + { + "idiom" : "universal", + "filename" : "LaunchImage@2x.png", + "scale" : "2x" + }, + { + "idiom" : "universal", + "filename" : "LaunchImage@3x.png", + "scale" : "3x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png new file mode 100644 index 00000000000..9da19eacad3 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png new file mode 100644 index 00000000000..9da19eacad3 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png new file mode 100644 index 00000000000..9da19eacad3 Binary files /dev/null and b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png differ diff --git a/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md new file mode 100644 index 00000000000..89c2725b70f --- /dev/null +++ b/gemini_tasks/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md @@ -0,0 +1,5 @@ +# Launch Screen Assets + +You can customize the launch screen with your own desired assets by replacing the image files in this directory. + +You can also do it by opening your Flutter project's Xcode project with `open ios/Runner.xcworkspace`, selecting `Runner/Assets.xcassets` in the Project Navigator and dropping in the desired images. \ No newline at end of file diff --git a/gemini_tasks/ios/Runner/Base.lproj/LaunchScreen.storyboard b/gemini_tasks/ios/Runner/Base.lproj/LaunchScreen.storyboard new file mode 100644 index 00000000000..f2e259c7c93 --- /dev/null +++ b/gemini_tasks/ios/Runner/Base.lproj/LaunchScreen.storyboard @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gemini_tasks/ios/Runner/Base.lproj/Main.storyboard b/gemini_tasks/ios/Runner/Base.lproj/Main.storyboard new file mode 100644 index 00000000000..f3c28516fb3 --- /dev/null +++ b/gemini_tasks/ios/Runner/Base.lproj/Main.storyboard @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gemini_tasks/ios/Runner/Info.plist b/gemini_tasks/ios/Runner/Info.plist new file mode 100644 index 00000000000..d86ff26a556 --- /dev/null +++ b/gemini_tasks/ios/Runner/Info.plist @@ -0,0 +1,49 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleDisplayName + Gemini Tasks + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + gemini_tasks + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleSignature + ???? + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSRequiresIPhoneOS + + UILaunchStoryboardName + LaunchScreen + UIMainStoryboardFile + Main + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + CADisableMinimumFrameDurationOnPhone + + UIApplicationSupportsIndirectInputEvents + + + diff --git a/gemini_tasks/ios/Runner/Runner-Bridging-Header.h b/gemini_tasks/ios/Runner/Runner-Bridging-Header.h new file mode 100644 index 00000000000..308a2a560b4 --- /dev/null +++ b/gemini_tasks/ios/Runner/Runner-Bridging-Header.h @@ -0,0 +1 @@ +#import "GeneratedPluginRegistrant.h" diff --git a/gemini_tasks/ios/RunnerTests/RunnerTests.swift b/gemini_tasks/ios/RunnerTests/RunnerTests.swift new file mode 100644 index 00000000000..86a7c3b1b61 --- /dev/null +++ b/gemini_tasks/ios/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import Flutter +import UIKit +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/gemini_tasks/lib/main.dart b/gemini_tasks/lib/main.dart new file mode 100644 index 00000000000..7c8d73b7f69 --- /dev/null +++ b/gemini_tasks/lib/main.dart @@ -0,0 +1,420 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import 'dart:async'; + +import 'package:flutter/material.dart'; +import 'package:google_generative_ai/google_generative_ai.dart'; + +import 'widgets/api_key_widget.dart'; +import 'widgets/message_widget.dart'; +import 'widgets/text_field_decoration.dart'; + +typedef Task = ( + int id, { + String name, + String? description, + bool completed, +}); + +extension on Task { + Map toJson() { + return { + 'id': $1, + 'name': name, + 'description': description, + 'completed': completed, + }; + } +} + +final themeColor = ValueNotifier(Colors.orangeAccent); +final tasks = ValueNotifier([]); +int lastId = 0; + +void main() { + runApp(const GenerativeAISample(title: "Gemini Tasks")); +} + +class GenerativeAISample extends StatefulWidget { + const GenerativeAISample({super.key, required this.title}); + final String title; + + @override + State createState() => _GenerativeAISampleState(); +} + +class _GenerativeAISampleState extends State { + String? apiKey; + + ThemeData theme(Brightness brightness) { + final colors = ColorScheme.fromSeed( + brightness: brightness, + seedColor: themeColor.value, + ); + return ThemeData( + brightness: brightness, + colorScheme: colors, + scaffoldBackgroundColor: colors.surface, + ); + } + + @override + Widget build(BuildContext context) { + return AnimatedBuilder( + animation: themeColor, + builder: (context, child) { + return MaterialApp( + debugShowCheckedModeBanner: false, + title: widget.title, + theme: theme(Brightness.light), + darkTheme: theme(Brightness.dark), + themeMode: ThemeMode.system, + home: switch (apiKey) { + final providedKey? => Example( + title: widget.title, + apiKey: providedKey, + ), + _ => ApiKeyWidget( + title: widget.title, + onSubmitted: (key) { + setState(() => apiKey = key); + }, + ), + }, + ); + }, + ); + } +} + +class Example extends StatefulWidget { + const Example({ + super.key, + required this.apiKey, + required this.title, + }); + + final String apiKey, title; + + @override + State createState() => _ExampleState(); +} + +class _ExampleState extends State { + final loading = ValueNotifier(false); + final menu = ValueNotifier(''); + final messages = ValueNotifier>([]); + final controller = TextEditingController(); + late final _history = []; + + late final model = GenerativeModel( + model: 'gemini-pro', + apiKey: widget.apiKey, + requestOptions: const RequestOptions(apiVersion: 'v1beta'), + + // systemInstruction: Content.text( + // 'You are a task bot that can complete, add, ' + // 'and filter tasks for a todo style application.', + // ), + tools: [ + Tool( + functionDeclarations: [ + FunctionDeclaration( + 'add_task', + 'Add a new task to the list', + Schema( + SchemaType.object, + properties: { + 'name': Schema( + SchemaType.string, + ), + 'description': Schema( + SchemaType.string, + nullable: true, + ), + }, + ), + ), + FunctionDeclaration( + 'get_completed_tasks', + 'Return all the completed tasks in the list', + Schema( + SchemaType.object, + properties: { + 'name': Schema( + SchemaType.string, + nullable: true, + description: 'Search filter for name', + ), + 'description': Schema( + SchemaType.string, + nullable: true, + description: 'Search filter for description', + ), + }, + ), + ), + FunctionDeclaration( + 'get_active_tasks', + 'Return all the active tasks in the list', + Schema( + SchemaType.object, + properties: { + 'name': Schema( + SchemaType.string, + nullable: true, + description: 'Search filter for name', + ), + 'description': Schema( + SchemaType.string, + nullable: true, + description: 'Search filter for description', + ), + }, + ), + ), + FunctionDeclaration( + 'update_task', + 'Update a task in the list', + Schema( + SchemaType.object, + properties: { + 'name': Schema( + SchemaType.string, + description: 'Task name', + ), + 'description': Schema( + SchemaType.string, + nullable: true, + description: 'Task description', + ), + 'completed': Schema( + SchemaType.boolean, + nullable: true, + description: 'Task status', + ), + }, + ), + ), + ], + ), + ], + ); + + Future sendMessage() async { + final message = controller.text.trim(); + if (message.isEmpty) return; + controller.clear(); + addMessage(Sender.user, message); + loading.value = true; + try { + final prompt = StringBuffer(); + prompt.writeln( + 'If the following is not a question assume' + 'it is a new task to be added:', + ); + prompt.writeln(message); + final response = await callWithActions([Content.text(prompt.toString())]); + if (response.text != null) { + addMessage(Sender.system, response.text!); + } else { + addMessage(Sender.system, 'Something went wrong, please try again.'); + } + } catch (e) { + addMessage(Sender.system, 'Error sending message: $e'); + } finally { + loading.value = false; + } + } + + Future callWithActions( + Iterable prompt, + ) async { + final response = await model.generateContent( + _history.followedBy(prompt), + ); + if (response.candidates.isNotEmpty) { + _history.addAll(prompt); + _history.add(response.candidates.first.content); + } + final actions = []; + for (final fn in response.functionCalls) { + final current = tasks.value.toList(); + final args = fn.args; + switch (fn.name) { + case 'add_task': + final name = args['name'] as String; + final description = args['description'] as String?; + final Task task = ( + ++lastId, + name: name, + description: description, + completed: false, + ); + current.add(task); + tasks.value = current; + actions.add(FunctionResponse( + fn.name, + task.toJson(), + )); + break; + case 'get_completed_tasks': + var filter = + current.toList().where((e) => e.completed == true).toList(); + final name = args['name'] as String?; + final description = args['description'] as String?; + if (name != null) { + filter = filter.where((e) => e.name.contains(name)).toList(); + } + if (description != null) { + filter = filter + .where((e) => e.description?.contains(description) ?? false) + .toList(); + } + actions.add(FunctionResponse( + fn.name, + {'tasks': filter.map((e) => e.toJson()).toList()}, + )); + break; + case 'get_active_tasks': + var filter = + current.toList().where((e) => e.completed == false).toList(); + final name = args['name'] as String?; + final description = args['description'] as String?; + if (name != null) { + filter = filter.where((e) => e.name.contains(name)).toList(); + } + if (description != null) { + filter = filter + .where((e) => e.description?.contains(description) ?? false) + .toList(); + } + actions.add(FunctionResponse( + fn.name, + {'tasks': filter.map((e) => e.toJson()).toList()}, + )); + break; + case 'update_task': + final name = args['name'] as String?; + final idx = current.indexWhere((e) => e.name == name); + if (idx == -1) { + actions.add(FunctionResponse( + fn.name, + {"type": "error", 'message': 'Task with "$name" id not found'}, + )); + continue; + } + final task = current[idx]; + current[idx] = ( + task.$1, + name: args['name'] as String? ?? task.name, + description: args['description'] as String? ?? task.description, + completed: args['completed'] as bool? ?? task.completed, + ); + tasks.value = current; + actions.add(FunctionResponse( + fn.name, + current[idx].toJson(), + )); + break; + default: + } + } + if (actions.isNotEmpty) { + return await callWithActions([ + ...prompt, + if (response.functionCalls.isNotEmpty) + Content.model(response.functionCalls), + for (final res in actions) + Content.functionResponse(res.name, res.response), + ]); + } + return response; + } + + void addMessage(Sender sender, String value, {bool clear = false}) { + if (clear) { + _history.clear(); + messages.value = []; + } + messages.value = messages.value.toList()..add((sender, value)); + } + + @override + Widget build(BuildContext context) { + return AnimatedBuilder( + animation: messages, + builder: (context, child) { + final reversed = messages.value.reversed; + return Scaffold( + appBar: AppBar( + title: Text(widget.title), + ), + body: messages.value.isEmpty + ? const Center(child: Text('No tasks found')) + : ListView.builder( + padding: const EdgeInsets.all(8), + reverse: true, + itemCount: reversed.length, + itemBuilder: (context, index) { + final (sender, message) = reversed.elementAt(index); + return MessageWidget( + isFromUser: sender == Sender.user, + text: message, + ); + }, + ), + bottomNavigationBar: BottomAppBar( + padding: const EdgeInsets.all(8), + child: Row( + children: [ + Expanded( + child: TextField( + controller: controller, + decoration: textFieldDecoration( + context, + 'Try "Add a task for..." or "What are my ucompleted ' + 'tasks?"'), + onEditingComplete: sendMessage, + onSubmitted: (value) => sendMessage(), + ), + ), + const SizedBox(width: 8), + AnimatedBuilder( + animation: loading, + builder: (context, _) { + if (loading.value) { + return const CircularProgressIndicator(); + } + return IconButton( + onPressed: sendMessage, + icon: const Icon(Icons.send), + tooltip: 'Send a message', + ); + }, + ), + ], + ), + ), + ); + }, + ); + } +} + +enum Sender { + user, + system, +} diff --git a/gemini_tasks/lib/widgets/api_key_widget.dart b/gemini_tasks/lib/widgets/api_key_widget.dart new file mode 100644 index 00000000000..244d922b823 --- /dev/null +++ b/gemini_tasks/lib/widgets/api_key_widget.dart @@ -0,0 +1,88 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import 'package:flutter/material.dart'; +import 'package:url_launcher/link.dart'; + +import 'text_field_decoration.dart'; + +class ApiKeyWidget extends StatelessWidget { + ApiKeyWidget({ + super.key, + required this.onSubmitted, + required this.title, + }); + + final String title; + final ValueChanged onSubmitted; + final _textController = TextEditingController(); + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text(title), + ), + body: Center( + child: Padding( + padding: const EdgeInsets.all(8.0), + child: Column( + mainAxisSize: MainAxisSize.min, + children: [ + const Text( + 'To use the Gemini API, you\'ll need an API key. ' + 'If you don\'t already have one, ' + 'create a key in Google AI Studio.', + textAlign: TextAlign.center, + ), + const SizedBox(height: 8), + Link( + uri: Uri.https('aistudio.google.com', '/app/apikey'), + target: LinkTarget.blank, + builder: (context, followLink) => TextButton( + onPressed: followLink, + child: const Text('Get an API Key'), + ), + ), + ], + ), + ), + ), + bottomNavigationBar: BottomAppBar( + padding: const EdgeInsets.all(8), + child: Row( + children: [ + Expanded( + child: TextField( + decoration: textFieldDecoration(context, 'Enter your API key'), + controller: _textController, + obscureText: true, + onSubmitted: (value) { + onSubmitted(value); + }, + ), + ), + const SizedBox(height: 8), + TextButton( + onPressed: () { + onSubmitted(_textController.value.text); + }, + child: const Text('Submit'), + ), + ], + ), + ), + ); + } +} diff --git a/gemini_tasks/lib/widgets/message_widget.dart b/gemini_tasks/lib/widgets/message_widget.dart new file mode 100644 index 00000000000..3aac0f9db70 --- /dev/null +++ b/gemini_tasks/lib/widgets/message_widget.dart @@ -0,0 +1,59 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import 'package:flutter/material.dart'; +import 'package:flutter_markdown/flutter_markdown.dart'; + +class MessageWidget extends StatelessWidget { + const MessageWidget({ + super.key, + this.text, + this.image, + required this.isFromUser, + }); + + final Image? image; + final String? text; + final bool isFromUser; + + @override + Widget build(BuildContext context) { + return Row( + mainAxisAlignment: + isFromUser ? MainAxisAlignment.end : MainAxisAlignment.start, + children: [ + Flexible( + child: Container( + constraints: const BoxConstraints(maxWidth: 520), + decoration: BoxDecoration( + color: isFromUser + ? Theme.of(context).colorScheme.primaryContainer + : Theme.of(context).colorScheme.surfaceVariant, + borderRadius: BorderRadius.circular(18), + ), + padding: const EdgeInsets.symmetric( + vertical: 15, + horizontal: 20, + ), + margin: const EdgeInsets.only(bottom: 8), + child: Column(children: [ + if (text case final text?) MarkdownBody(data: text), + if (image case final image?) image, + ]), + ), + ), + ], + ); + } +} diff --git a/gemini_tasks/lib/widgets/text_field_decoration.dart b/gemini_tasks/lib/widgets/text_field_decoration.dart new file mode 100644 index 00000000000..cdc9abd37bc --- /dev/null +++ b/gemini_tasks/lib/widgets/text_field_decoration.dart @@ -0,0 +1,38 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import 'package:flutter/material.dart'; + +InputDecoration textFieldDecoration(BuildContext context, String hintText) { + return InputDecoration( + contentPadding: const EdgeInsets.all(15), + hintText: hintText, + border: OutlineInputBorder( + borderRadius: const BorderRadius.all( + Radius.circular(14), + ), + borderSide: BorderSide( + color: Theme.of(context).colorScheme.secondary, + ), + ), + focusedBorder: OutlineInputBorder( + borderRadius: const BorderRadius.all( + Radius.circular(14), + ), + borderSide: BorderSide( + color: Theme.of(context).colorScheme.secondary, + ), + ), + ); +} diff --git a/gemini_tasks/linux/.gitignore b/gemini_tasks/linux/.gitignore new file mode 100644 index 00000000000..d3896c98444 --- /dev/null +++ b/gemini_tasks/linux/.gitignore @@ -0,0 +1 @@ +flutter/ephemeral diff --git a/gemini_tasks/linux/CMakeLists.txt b/gemini_tasks/linux/CMakeLists.txt new file mode 100644 index 00000000000..c394ffce3f1 --- /dev/null +++ b/gemini_tasks/linux/CMakeLists.txt @@ -0,0 +1,145 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.10) +project(runner LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "gemini_tasks") +# The unique GTK application identifier for this application. See: +# https://wiki.gnome.org/HowDoI/ChooseApplicationID +set(APPLICATION_ID "com.example.gemini_tasks") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(SET CMP0063 NEW) + +# Load bundled libraries from the lib/ directory relative to the binary. +set(CMAKE_INSTALL_RPATH "$ORIGIN/lib") + +# Root filesystem for cross-building. +if(FLUTTER_TARGET_PLATFORM_SYSROOT) + set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endif() + +# Define build configuration options. +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") +endif() + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_14) + target_compile_options(${TARGET} PRIVATE -Wall -Werror) + target_compile_options(${TARGET} PRIVATE "$<$>:-O3>") + target_compile_definitions(${TARGET} PRIVATE "$<$>:NDEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) + +add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}") + +# Define the application target. To change its name, change BINARY_NAME above, +# not the value here, or `flutter run` will no longer work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} + "main.cc" + "my_application.cc" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add dependency libraries. Add any application-specific dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter) +target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK) + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) + +# Only the install-generated bundle's copy of the executable will launch +# correctly, since the resources must in the right relative locations. To avoid +# people trying to run the unbundled copy, put it in a subdirectory instead of +# the default top-level location. +set_target_properties(${BINARY_NAME} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run" +) + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# By default, "installing" just makes a relocatable bundle in the build +# directory. +set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle") +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +# Start with a clean build bundle directory every time. +install(CODE " + file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\") + " COMPONENT Runtime) + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES}) + install(FILES "${bundled_library}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endforeach(bundled_library) + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +if(NOT CMAKE_BUILD_TYPE MATCHES "Debug") + install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() diff --git a/gemini_tasks/linux/flutter/CMakeLists.txt b/gemini_tasks/linux/flutter/CMakeLists.txt new file mode 100644 index 00000000000..d5bd01648a9 --- /dev/null +++ b/gemini_tasks/linux/flutter/CMakeLists.txt @@ -0,0 +1,88 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.10) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. + +# Serves the same purpose as list(TRANSFORM ... PREPEND ...), +# which isn't available in 3.10. +function(list_prepend LIST_NAME PREFIX) + set(NEW_LIST "") + foreach(element ${${LIST_NAME}}) + list(APPEND NEW_LIST "${PREFIX}${element}") + endforeach(element) + set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE) +endfunction() + +# === Flutter Library === +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) +pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0) +pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0) + +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "fl_basic_message_channel.h" + "fl_binary_codec.h" + "fl_binary_messenger.h" + "fl_dart_project.h" + "fl_engine.h" + "fl_json_message_codec.h" + "fl_json_method_codec.h" + "fl_message_codec.h" + "fl_method_call.h" + "fl_method_channel.h" + "fl_method_codec.h" + "fl_method_response.h" + "fl_plugin_registrar.h" + "fl_plugin_registry.h" + "fl_standard_message_codec.h" + "fl_standard_method_codec.h" + "fl_string_codec.h" + "fl_value.h" + "fl_view.h" + "flutter_linux.h" +) +list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}") +target_link_libraries(flutter INTERFACE + PkgConfig::GTK + PkgConfig::GLIB + PkgConfig::GIO +) +add_dependencies(flutter flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CMAKE_CURRENT_BINARY_DIR}/_phony_ + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh" + ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE} + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} +) diff --git a/gemini_tasks/linux/flutter/generated_plugin_registrant.cc b/gemini_tasks/linux/flutter/generated_plugin_registrant.cc new file mode 100644 index 00000000000..f6f23bfe970 --- /dev/null +++ b/gemini_tasks/linux/flutter/generated_plugin_registrant.cc @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + +#include + +void fl_register_plugins(FlPluginRegistry* registry) { + g_autoptr(FlPluginRegistrar) url_launcher_linux_registrar = + fl_plugin_registry_get_registrar_for_plugin(registry, "UrlLauncherPlugin"); + url_launcher_plugin_register_with_registrar(url_launcher_linux_registrar); +} diff --git a/gemini_tasks/linux/flutter/generated_plugin_registrant.h b/gemini_tasks/linux/flutter/generated_plugin_registrant.h new file mode 100644 index 00000000000..e0f0a47bc08 --- /dev/null +++ b/gemini_tasks/linux/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void fl_register_plugins(FlPluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/gemini_tasks/linux/flutter/generated_plugins.cmake b/gemini_tasks/linux/flutter/generated_plugins.cmake new file mode 100644 index 00000000000..f16b4c34213 --- /dev/null +++ b/gemini_tasks/linux/flutter/generated_plugins.cmake @@ -0,0 +1,24 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST + url_launcher_linux +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/gemini_tasks/linux/main.cc b/gemini_tasks/linux/main.cc new file mode 100644 index 00000000000..e7c5c543703 --- /dev/null +++ b/gemini_tasks/linux/main.cc @@ -0,0 +1,6 @@ +#include "my_application.h" + +int main(int argc, char** argv) { + g_autoptr(MyApplication) app = my_application_new(); + return g_application_run(G_APPLICATION(app), argc, argv); +} diff --git a/gemini_tasks/linux/my_application.cc b/gemini_tasks/linux/my_application.cc new file mode 100644 index 00000000000..5d36060db25 --- /dev/null +++ b/gemini_tasks/linux/my_application.cc @@ -0,0 +1,124 @@ +#include "my_application.h" + +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#include "flutter/generated_plugin_registrant.h" + +struct _MyApplication { + GtkApplication parent_instance; + char** dart_entrypoint_arguments; +}; + +G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION) + +// Implements GApplication::activate. +static void my_application_activate(GApplication* application) { + MyApplication* self = MY_APPLICATION(application); + GtkWindow* window = + GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application))); + + // Use a header bar when running in GNOME as this is the common style used + // by applications and is the setup most users will be using (e.g. Ubuntu + // desktop). + // If running on X and not using GNOME then just use a traditional title bar + // in case the window manager does more exotic layout, e.g. tiling. + // If running on Wayland assume the header bar will work (may need changing + // if future cases occur). + gboolean use_header_bar = TRUE; +#ifdef GDK_WINDOWING_X11 + GdkScreen* screen = gtk_window_get_screen(window); + if (GDK_IS_X11_SCREEN(screen)) { + const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen); + if (g_strcmp0(wm_name, "GNOME Shell") != 0) { + use_header_bar = FALSE; + } + } +#endif + if (use_header_bar) { + GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new()); + gtk_widget_show(GTK_WIDGET(header_bar)); + gtk_header_bar_set_title(header_bar, "gemini_tasks"); + gtk_header_bar_set_show_close_button(header_bar, TRUE); + gtk_window_set_titlebar(window, GTK_WIDGET(header_bar)); + } else { + gtk_window_set_title(window, "gemini_tasks"); + } + + gtk_window_set_default_size(window, 1280, 720); + gtk_widget_show(GTK_WIDGET(window)); + + g_autoptr(FlDartProject) project = fl_dart_project_new(); + fl_dart_project_set_dart_entrypoint_arguments(project, self->dart_entrypoint_arguments); + + FlView* view = fl_view_new(project); + gtk_widget_show(GTK_WIDGET(view)); + gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view)); + + fl_register_plugins(FL_PLUGIN_REGISTRY(view)); + + gtk_widget_grab_focus(GTK_WIDGET(view)); +} + +// Implements GApplication::local_command_line. +static gboolean my_application_local_command_line(GApplication* application, gchar*** arguments, int* exit_status) { + MyApplication* self = MY_APPLICATION(application); + // Strip out the first argument as it is the binary name. + self->dart_entrypoint_arguments = g_strdupv(*arguments + 1); + + g_autoptr(GError) error = nullptr; + if (!g_application_register(application, nullptr, &error)) { + g_warning("Failed to register: %s", error->message); + *exit_status = 1; + return TRUE; + } + + g_application_activate(application); + *exit_status = 0; + + return TRUE; +} + +// Implements GApplication::startup. +static void my_application_startup(GApplication* application) { + //MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application startup. + + G_APPLICATION_CLASS(my_application_parent_class)->startup(application); +} + +// Implements GApplication::shutdown. +static void my_application_shutdown(GApplication* application) { + //MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application shutdown. + + G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application); +} + +// Implements GObject::dispose. +static void my_application_dispose(GObject* object) { + MyApplication* self = MY_APPLICATION(object); + g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev); + G_OBJECT_CLASS(my_application_parent_class)->dispose(object); +} + +static void my_application_class_init(MyApplicationClass* klass) { + G_APPLICATION_CLASS(klass)->activate = my_application_activate; + G_APPLICATION_CLASS(klass)->local_command_line = my_application_local_command_line; + G_APPLICATION_CLASS(klass)->startup = my_application_startup; + G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown; + G_OBJECT_CLASS(klass)->dispose = my_application_dispose; +} + +static void my_application_init(MyApplication* self) {} + +MyApplication* my_application_new() { + return MY_APPLICATION(g_object_new(my_application_get_type(), + "application-id", APPLICATION_ID, + "flags", G_APPLICATION_NON_UNIQUE, + nullptr)); +} diff --git a/gemini_tasks/linux/my_application.h b/gemini_tasks/linux/my_application.h new file mode 100644 index 00000000000..72271d5e417 --- /dev/null +++ b/gemini_tasks/linux/my_application.h @@ -0,0 +1,18 @@ +#ifndef FLUTTER_MY_APPLICATION_H_ +#define FLUTTER_MY_APPLICATION_H_ + +#include + +G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION, + GtkApplication) + +/** + * my_application_new: + * + * Creates a new Flutter-based application. + * + * Returns: a new #MyApplication. + */ +MyApplication* my_application_new(); + +#endif // FLUTTER_MY_APPLICATION_H_ diff --git a/gemini_tasks/macos/.gitignore b/gemini_tasks/macos/.gitignore new file mode 100644 index 00000000000..746adbb6b9e --- /dev/null +++ b/gemini_tasks/macos/.gitignore @@ -0,0 +1,7 @@ +# Flutter-related +**/Flutter/ephemeral/ +**/Pods/ + +# Xcode-related +**/dgph +**/xcuserdata/ diff --git a/gemini_tasks/macos/Flutter/Flutter-Debug.xcconfig b/gemini_tasks/macos/Flutter/Flutter-Debug.xcconfig new file mode 100644 index 00000000000..4b81f9b2d20 --- /dev/null +++ b/gemini_tasks/macos/Flutter/Flutter-Debug.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig" +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/gemini_tasks/macos/Flutter/Flutter-Release.xcconfig b/gemini_tasks/macos/Flutter/Flutter-Release.xcconfig new file mode 100644 index 00000000000..5caa9d1579e --- /dev/null +++ b/gemini_tasks/macos/Flutter/Flutter-Release.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig" +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/gemini_tasks/macos/Flutter/GeneratedPluginRegistrant.swift b/gemini_tasks/macos/Flutter/GeneratedPluginRegistrant.swift new file mode 100644 index 00000000000..8236f5728c6 --- /dev/null +++ b/gemini_tasks/macos/Flutter/GeneratedPluginRegistrant.swift @@ -0,0 +1,12 @@ +// +// Generated file. Do not edit. +// + +import FlutterMacOS +import Foundation + +import url_launcher_macos + +func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) { + UrlLauncherPlugin.register(with: registry.registrar(forPlugin: "UrlLauncherPlugin")) +} diff --git a/gemini_tasks/macos/Podfile b/gemini_tasks/macos/Podfile new file mode 100644 index 00000000000..c795730db8e --- /dev/null +++ b/gemini_tasks/macos/Podfile @@ -0,0 +1,43 @@ +platform :osx, '10.14' + +# CocoaPods analytics sends network stats synchronously affecting flutter build latency. +ENV['COCOAPODS_DISABLE_STATS'] = 'true' + +project 'Runner', { + 'Debug' => :debug, + 'Profile' => :release, + 'Release' => :release, +} + +def flutter_root + generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'ephemeral', 'Flutter-Generated.xcconfig'), __FILE__) + unless File.exist?(generated_xcode_build_settings_path) + raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure \"flutter pub get\" is executed first" + end + + File.foreach(generated_xcode_build_settings_path) do |line| + matches = line.match(/FLUTTER_ROOT\=(.*)/) + return matches[1].strip if matches + end + raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Flutter-Generated.xcconfig, then run \"flutter pub get\"" +end + +require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root) + +flutter_macos_podfile_setup + +target 'Runner' do + use_frameworks! + use_modular_headers! + + flutter_install_all_macos_pods File.dirname(File.realpath(__FILE__)) + target 'RunnerTests' do + inherit! :search_paths + end +end + +post_install do |installer| + installer.pods_project.targets.each do |target| + flutter_additional_macos_build_settings(target) + end +end diff --git a/gemini_tasks/macos/Runner.xcodeproj/project.pbxproj b/gemini_tasks/macos/Runner.xcodeproj/project.pbxproj new file mode 100644 index 00000000000..b649f94883c --- /dev/null +++ b/gemini_tasks/macos/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,801 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXAggregateTarget section */ + 33CC111A2044C6BA0003C045 /* Flutter Assemble */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */; + buildPhases = ( + 33CC111E2044C6BF0003C045 /* ShellScript */, + ); + dependencies = ( + ); + name = "Flutter Assemble"; + productName = FLX; + }; +/* End PBXAggregateTarget section */ + +/* Begin PBXBuildFile section */ + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C80D7294CF71000263BE5 /* RunnerTests.swift */; }; + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */ = {isa = PBXBuildFile; fileRef = 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */; }; + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC10F02044A3C60003C045 /* AppDelegate.swift */; }; + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F22044A3C60003C045 /* Assets.xcassets */; }; + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F42044A3C60003C045 /* MainMenu.xib */; }; + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */; }; + 569AB26DE3325218E22E891D /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 9BC72FCA0EA409398BE36D32 /* Pods_RunnerTests.framework */; }; + 7AAA3C27EF6962C0AB012BD5 /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 3D5B3285CC002B474B68160E /* Pods_Runner.framework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC10EC2044A3C60003C045; + remoteInfo = Runner; + }; + 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC111A2044C6BA0003C045; + remoteInfo = FLX; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 33CC110E2044A8840003C045 /* Bundle Framework */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Bundle Framework"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 0963E172D33D9015B461746A /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = ""; }; + 0F3D4D3AEF8B7B1DC146C6D9 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = ""; }; + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 331C80D7294CF71000263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Warnings.xcconfig; sourceTree = ""; }; + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GeneratedPluginRegistrant.swift; sourceTree = ""; }; + 33CC10ED2044A3C60003C045 /* gemini_tasks.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = gemini_tasks.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 33CC10F02044A3C60003C045 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 33CC10F22044A3C60003C045 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Assets.xcassets; path = Runner/Assets.xcassets; sourceTree = ""; }; + 33CC10F52044A3C60003C045 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MainMenu.xib; sourceTree = ""; }; + 33CC10F72044A3C60003C045 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Info.plist; path = Runner/Info.plist; sourceTree = ""; }; + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainFlutterWindow.swift; sourceTree = ""; }; + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Debug.xcconfig"; sourceTree = ""; }; + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Release.xcconfig"; sourceTree = ""; }; + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "Flutter-Generated.xcconfig"; path = "ephemeral/Flutter-Generated.xcconfig"; sourceTree = ""; }; + 33E51913231747F40026EE4D /* DebugProfile.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = DebugProfile.entitlements; sourceTree = ""; }; + 33E51914231749380026EE4D /* Release.entitlements */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.entitlements; path = Release.entitlements; sourceTree = ""; }; + 33E5194F232828860026EE4D /* AppInfo.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AppInfo.xcconfig; sourceTree = ""; }; + 3D5B3285CC002B474B68160E /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 4A1CF1EC01D6AD68142F5DDF /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = ""; }; + 5C8145B773E109388C918B05 /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = ""; }; + 917B1F16FE32F9DFF230E9C4 /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = ""; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = ""; }; + 9BC72FCA0EA409398BE36D32 /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + C597AD32E05276705DB27387 /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 331C80D2294CF70F00263BE5 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 569AB26DE3325218E22E891D /* Pods_RunnerTests.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EA2044A3C60003C045 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 7AAA3C27EF6962C0AB012BD5 /* Pods_Runner.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 331C80D6294CF71000263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C80D7294CF71000263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 33BA886A226E78AF003329D5 /* Configs */ = { + isa = PBXGroup; + children = ( + 33E5194F232828860026EE4D /* AppInfo.xcconfig */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */, + ); + path = Configs; + sourceTree = ""; + }; + 33CC10E42044A3C60003C045 = { + isa = PBXGroup; + children = ( + 33FAB671232836740065AC1E /* Runner */, + 33CEB47122A05771004F2AC0 /* Flutter */, + 331C80D6294CF71000263BE5 /* RunnerTests */, + 33CC10EE2044A3C60003C045 /* Products */, + D73912EC22F37F3D000D13A0 /* Frameworks */, + D031B94A0315E6B5F446D309 /* Pods */, + ); + sourceTree = ""; + }; + 33CC10EE2044A3C60003C045 /* Products */ = { + isa = PBXGroup; + children = ( + 33CC10ED2044A3C60003C045 /* gemini_tasks.app */, + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 33CC11242044D66E0003C045 /* Resources */ = { + isa = PBXGroup; + children = ( + 33CC10F22044A3C60003C045 /* Assets.xcassets */, + 33CC10F42044A3C60003C045 /* MainMenu.xib */, + 33CC10F72044A3C60003C045 /* Info.plist */, + ); + name = Resources; + path = ..; + sourceTree = ""; + }; + 33CEB47122A05771004F2AC0 /* Flutter */ = { + isa = PBXGroup; + children = ( + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */, + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */, + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */, + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */, + ); + path = Flutter; + sourceTree = ""; + }; + 33FAB671232836740065AC1E /* Runner */ = { + isa = PBXGroup; + children = ( + 33CC10F02044A3C60003C045 /* AppDelegate.swift */, + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */, + 33E51913231747F40026EE4D /* DebugProfile.entitlements */, + 33E51914231749380026EE4D /* Release.entitlements */, + 33CC11242044D66E0003C045 /* Resources */, + 33BA886A226E78AF003329D5 /* Configs */, + ); + path = Runner; + sourceTree = ""; + }; + D031B94A0315E6B5F446D309 /* Pods */ = { + isa = PBXGroup; + children = ( + 0F3D4D3AEF8B7B1DC146C6D9 /* Pods-Runner.debug.xcconfig */, + C597AD32E05276705DB27387 /* Pods-Runner.release.xcconfig */, + 5C8145B773E109388C918B05 /* Pods-Runner.profile.xcconfig */, + 0963E172D33D9015B461746A /* Pods-RunnerTests.debug.xcconfig */, + 4A1CF1EC01D6AD68142F5DDF /* Pods-RunnerTests.release.xcconfig */, + 917B1F16FE32F9DFF230E9C4 /* Pods-RunnerTests.profile.xcconfig */, + ); + name = Pods; + path = Pods; + sourceTree = ""; + }; + D73912EC22F37F3D000D13A0 /* Frameworks */ = { + isa = PBXGroup; + children = ( + 3D5B3285CC002B474B68160E /* Pods_Runner.framework */, + 9BC72FCA0EA409398BE36D32 /* Pods_RunnerTests.framework */, + ); + name = Frameworks; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C80D4294CF70F00263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 8A267290E2BCC08AD16F52BE /* [CP] Check Pods Manifest.lock */, + 331C80D1294CF70F00263BE5 /* Sources */, + 331C80D2294CF70F00263BE5 /* Frameworks */, + 331C80D3294CF70F00263BE5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 331C80DA294CF71000263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C80D5294CF71000263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 33CC10EC2044A3C60003C045 /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + D8C1514D662336E868B91BC4 /* [CP] Check Pods Manifest.lock */, + 33CC10E92044A3C60003C045 /* Sources */, + 33CC10EA2044A3C60003C045 /* Frameworks */, + 33CC10EB2044A3C60003C045 /* Resources */, + 33CC110E2044A8840003C045 /* Bundle Framework */, + 3399D490228B24CF009A79C7 /* ShellScript */, + F9FC7745EC629FF04811CC5D /* [CP] Embed Pods Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 33CC11202044C79F0003C045 /* PBXTargetDependency */, + ); + name = Runner; + productName = Runner; + productReference = 33CC10ED2044A3C60003C045 /* gemini_tasks.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 33CC10E52044A3C60003C045 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastSwiftUpdateCheck = 0920; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C80D4294CF70F00263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 33CC10EC2044A3C60003C045; + }; + 33CC10EC2044A3C60003C045 = { + CreatedOnToolsVersion = 9.2; + LastSwiftMigration = 1100; + ProvisioningStyle = Automatic; + SystemCapabilities = { + com.apple.Sandbox = { + enabled = 1; + }; + }; + }; + 33CC111A2044C6BA0003C045 = { + CreatedOnToolsVersion = 9.2; + ProvisioningStyle = Manual; + }; + }; + }; + buildConfigurationList = 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 33CC10E42044A3C60003C045; + productRefGroup = 33CC10EE2044A3C60003C045 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 33CC10EC2044A3C60003C045 /* Runner */, + 331C80D4294CF70F00263BE5 /* RunnerTests */, + 33CC111A2044C6BA0003C045 /* Flutter Assemble */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C80D3294CF70F00263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EB2044A3C60003C045 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */, + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 3399D490228B24CF009A79C7 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "echo \"$PRODUCT_NAME.app\" > \"$PROJECT_DIR\"/Flutter/ephemeral/.app_filename && \"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh embed\n"; + }; + 33CC111E2044C6BF0003C045 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + Flutter/ephemeral/FlutterInputs.xcfilelist, + ); + inputPaths = ( + Flutter/ephemeral/tripwire, + ); + outputFileListPaths = ( + Flutter/ephemeral/FlutterOutputs.xcfilelist, + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh && touch Flutter/ephemeral/tripwire"; + }; + 8A267290E2BCC08AD16F52BE /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-RunnerTests-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; + D8C1514D662336E868B91BC4 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-Runner-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; + F9FC7745EC629FF04811CC5D /* [CP] Embed Pods Frameworks */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist", + ); + name = "[CP] Embed Pods Frameworks"; + outputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n"; + showEnvVarsInLog = 0; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C80D1294CF70F00263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10E92044A3C60003C045 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */, + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */, + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C80DA294CF71000263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC10EC2044A3C60003C045 /* Runner */; + targetProxy = 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */; + }; + 33CC11202044C79F0003C045 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC111A2044C6BA0003C045 /* Flutter Assemble */; + targetProxy = 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 33CC10F42044A3C60003C045 /* MainMenu.xib */ = { + isa = PBXVariantGroup; + children = ( + 33CC10F52044A3C60003C045 /* Base */, + ); + name = MainMenu.xib; + path = Runner; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 331C80DB294CF71000263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 0963E172D33D9015B461746A /* Pods-RunnerTests.debug.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/gemini_tasks.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/gemini_tasks"; + }; + name = Debug; + }; + 331C80DC294CF71000263BE5 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 4A1CF1EC01D6AD68142F5DDF /* Pods-RunnerTests.release.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/gemini_tasks.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/gemini_tasks"; + }; + name = Release; + }; + 331C80DD294CF71000263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 917B1F16FE32F9DFF230E9C4 /* Pods-RunnerTests.profile.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/gemini_tasks.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/gemini_tasks"; + }; + name = Profile; + }; + 338D0CE9231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Profile; + }; + 338D0CEA231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Profile; + }; + 338D0CEB231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Profile; + }; + 33CC10F92044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + 33CC10FA2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Release; + }; + 33CC10FC2044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + }; + name = Debug; + }; + 33CC10FD2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/Release.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Release; + }; + 33CC111C2044C6BA0003C045 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 33CC111D2044C6BA0003C045 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C80DB294CF71000263BE5 /* Debug */, + 331C80DC294CF71000263BE5 /* Release */, + 331C80DD294CF71000263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10F92044A3C60003C045 /* Debug */, + 33CC10FA2044A3C60003C045 /* Release */, + 338D0CE9231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10FC2044A3C60003C045 /* Debug */, + 33CC10FD2044A3C60003C045 /* Release */, + 338D0CEA231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC111C2044C6BA0003C045 /* Debug */, + 33CC111D2044C6BA0003C045 /* Release */, + 338D0CEB231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 33CC10E52044A3C60003C045 /* Project object */; +} diff --git a/gemini_tasks/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/gemini_tasks/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/gemini_tasks/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/gemini_tasks/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/gemini_tasks/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 00000000000..259e9c4cdf1 --- /dev/null +++ b/gemini_tasks/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gemini_tasks/macos/Runner.xcworkspace/contents.xcworkspacedata b/gemini_tasks/macos/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 00000000000..21a3cc14c74 --- /dev/null +++ b/gemini_tasks/macos/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,10 @@ + + + + + + + diff --git a/gemini_tasks/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/gemini_tasks/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/gemini_tasks/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/gemini_tasks/macos/Runner/AppDelegate.swift b/gemini_tasks/macos/Runner/AppDelegate.swift new file mode 100644 index 00000000000..d53ef643772 --- /dev/null +++ b/gemini_tasks/macos/Runner/AppDelegate.swift @@ -0,0 +1,9 @@ +import Cocoa +import FlutterMacOS + +@NSApplicationMain +class AppDelegate: FlutterAppDelegate { + override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { + return true + } +} diff --git a/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 00000000000..a2ec33f19f1 --- /dev/null +++ b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,68 @@ +{ + "images" : [ + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_16.png", + "scale" : "1x" + }, + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "2x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "1x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_64.png", + "scale" : "2x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_128.png", + "scale" : "1x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "2x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "1x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "2x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "1x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_1024.png", + "scale" : "2x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png new file mode 100644 index 00000000000..82b6f9d9a33 Binary files /dev/null and b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png differ diff --git a/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png new file mode 100644 index 00000000000..13b35eba55c Binary files /dev/null and b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png differ diff --git a/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png new file mode 100644 index 00000000000..0a3f5fa40fb Binary files /dev/null and b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png differ diff --git a/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png new file mode 100644 index 00000000000..bdb57226d5f Binary files /dev/null and b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png differ diff --git a/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png new file mode 100644 index 00000000000..f083318e09c Binary files /dev/null and b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png differ diff --git a/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png new file mode 100644 index 00000000000..326c0e72c9d Binary files /dev/null and b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png differ diff --git a/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png new file mode 100644 index 00000000000..2f1632cfddf Binary files /dev/null and b/gemini_tasks/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png differ diff --git a/gemini_tasks/macos/Runner/Base.lproj/MainMenu.xib b/gemini_tasks/macos/Runner/Base.lproj/MainMenu.xib new file mode 100644 index 00000000000..80e867a4e06 --- /dev/null +++ b/gemini_tasks/macos/Runner/Base.lproj/MainMenu.xib @@ -0,0 +1,343 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gemini_tasks/macos/Runner/Configs/AppInfo.xcconfig b/gemini_tasks/macos/Runner/Configs/AppInfo.xcconfig new file mode 100644 index 00000000000..cbbcf532e8f --- /dev/null +++ b/gemini_tasks/macos/Runner/Configs/AppInfo.xcconfig @@ -0,0 +1,14 @@ +// Application-level settings for the Runner target. +// +// This may be replaced with something auto-generated from metadata (e.g., pubspec.yaml) in the +// future. If not, the values below would default to using the project name when this becomes a +// 'flutter create' template. + +// The application's name. By default this is also the title of the Flutter window. +PRODUCT_NAME = gemini_tasks + +// The application's bundle identifier +PRODUCT_BUNDLE_IDENTIFIER = com.example.geminiTasks + +// The copyright displayed in application information +PRODUCT_COPYRIGHT = Copyright © 2024 com.example. All rights reserved. diff --git a/gemini_tasks/macos/Runner/Configs/Debug.xcconfig b/gemini_tasks/macos/Runner/Configs/Debug.xcconfig new file mode 100644 index 00000000000..36b0fd9464f --- /dev/null +++ b/gemini_tasks/macos/Runner/Configs/Debug.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Debug.xcconfig" +#include "Warnings.xcconfig" diff --git a/gemini_tasks/macos/Runner/Configs/Release.xcconfig b/gemini_tasks/macos/Runner/Configs/Release.xcconfig new file mode 100644 index 00000000000..dff4f49561c --- /dev/null +++ b/gemini_tasks/macos/Runner/Configs/Release.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Release.xcconfig" +#include "Warnings.xcconfig" diff --git a/gemini_tasks/macos/Runner/Configs/Warnings.xcconfig b/gemini_tasks/macos/Runner/Configs/Warnings.xcconfig new file mode 100644 index 00000000000..42bcbf4780b --- /dev/null +++ b/gemini_tasks/macos/Runner/Configs/Warnings.xcconfig @@ -0,0 +1,13 @@ +WARNING_CFLAGS = -Wall -Wconditional-uninitialized -Wnullable-to-nonnull-conversion -Wmissing-method-return-type -Woverlength-strings +GCC_WARN_UNDECLARED_SELECTOR = YES +CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES +CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE +CLANG_WARN__DUPLICATE_METHOD_MATCH = YES +CLANG_WARN_PRAGMA_PACK = YES +CLANG_WARN_STRICT_PROTOTYPES = YES +CLANG_WARN_COMMA = YES +GCC_WARN_STRICT_SELECTOR_MATCH = YES +CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK = YES +CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES +GCC_WARN_SHADOW = YES +CLANG_WARN_UNREACHABLE_CODE = YES diff --git a/gemini_tasks/macos/Runner/DebugProfile.entitlements b/gemini_tasks/macos/Runner/DebugProfile.entitlements new file mode 100644 index 00000000000..08c3ab17cc2 --- /dev/null +++ b/gemini_tasks/macos/Runner/DebugProfile.entitlements @@ -0,0 +1,14 @@ + + + + + com.apple.security.app-sandbox + + com.apple.security.cs.allow-jit + + com.apple.security.network.server + + com.apple.security.network.client + + + diff --git a/gemini_tasks/macos/Runner/Info.plist b/gemini_tasks/macos/Runner/Info.plist new file mode 100644 index 00000000000..4789daa6a44 --- /dev/null +++ b/gemini_tasks/macos/Runner/Info.plist @@ -0,0 +1,32 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIconFile + + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSMinimumSystemVersion + $(MACOSX_DEPLOYMENT_TARGET) + NSHumanReadableCopyright + $(PRODUCT_COPYRIGHT) + NSMainNibFile + MainMenu + NSPrincipalClass + NSApplication + + diff --git a/gemini_tasks/macos/Runner/MainFlutterWindow.swift b/gemini_tasks/macos/Runner/MainFlutterWindow.swift new file mode 100644 index 00000000000..3cc05eb2349 --- /dev/null +++ b/gemini_tasks/macos/Runner/MainFlutterWindow.swift @@ -0,0 +1,15 @@ +import Cocoa +import FlutterMacOS + +class MainFlutterWindow: NSWindow { + override func awakeFromNib() { + let flutterViewController = FlutterViewController() + let windowFrame = self.frame + self.contentViewController = flutterViewController + self.setFrame(windowFrame, display: true) + + RegisterGeneratedPlugins(registry: flutterViewController) + + super.awakeFromNib() + } +} diff --git a/gemini_tasks/macos/Runner/Release.entitlements b/gemini_tasks/macos/Runner/Release.entitlements new file mode 100644 index 00000000000..852fa1a4728 --- /dev/null +++ b/gemini_tasks/macos/Runner/Release.entitlements @@ -0,0 +1,8 @@ + + + + + com.apple.security.app-sandbox + + + diff --git a/gemini_tasks/macos/RunnerTests/RunnerTests.swift b/gemini_tasks/macos/RunnerTests/RunnerTests.swift new file mode 100644 index 00000000000..5418c9f5395 --- /dev/null +++ b/gemini_tasks/macos/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import FlutterMacOS +import Cocoa +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/gemini_tasks/pubspec.yaml b/gemini_tasks/pubspec.yaml new file mode 100644 index 00000000000..918ad4ca0c2 --- /dev/null +++ b/gemini_tasks/pubspec.yaml @@ -0,0 +1,21 @@ +name: gemini_tasks +description: "Sample app for the google_generative_ai package" +publish_to: 'none' +version: 1.0.0+1 +environment: + sdk: '>=3.3.0 <4.0.0' + +dependencies: + flutter: + sdk: flutter + flutter_markdown: ^0.7.1 + google_generative_ai: ^0.3.3 + url_launcher: ^6.2.6 + +dev_dependencies: + flutter_test: + sdk: flutter + flutter_lints: ^3.0.0 + +flutter: + uses-material-design: true diff --git a/gemini_tasks/web/favicon.png b/gemini_tasks/web/favicon.png new file mode 100644 index 00000000000..8aaa46ac1ae Binary files /dev/null and b/gemini_tasks/web/favicon.png differ diff --git a/gemini_tasks/web/icons/Icon-192.png b/gemini_tasks/web/icons/Icon-192.png new file mode 100644 index 00000000000..b749bfef074 Binary files /dev/null and b/gemini_tasks/web/icons/Icon-192.png differ diff --git a/gemini_tasks/web/icons/Icon-512.png b/gemini_tasks/web/icons/Icon-512.png new file mode 100644 index 00000000000..88cfd48dff1 Binary files /dev/null and b/gemini_tasks/web/icons/Icon-512.png differ diff --git a/gemini_tasks/web/icons/Icon-maskable-192.png b/gemini_tasks/web/icons/Icon-maskable-192.png new file mode 100644 index 00000000000..eb9b4d76e52 Binary files /dev/null and b/gemini_tasks/web/icons/Icon-maskable-192.png differ diff --git a/gemini_tasks/web/icons/Icon-maskable-512.png b/gemini_tasks/web/icons/Icon-maskable-512.png new file mode 100644 index 00000000000..d69c56691fb Binary files /dev/null and b/gemini_tasks/web/icons/Icon-maskable-512.png differ diff --git a/gemini_tasks/web/index.html b/gemini_tasks/web/index.html new file mode 100644 index 00000000000..a922f82f25c --- /dev/null +++ b/gemini_tasks/web/index.html @@ -0,0 +1,59 @@ + + + + + + + + + + + + + + + + + + + + gemini_tasks + + + + + + + + + + diff --git a/gemini_tasks/web/manifest.json b/gemini_tasks/web/manifest.json new file mode 100644 index 00000000000..31d30dc5e7c --- /dev/null +++ b/gemini_tasks/web/manifest.json @@ -0,0 +1,35 @@ +{ + "name": "gemini_tasks", + "short_name": "gemini_tasks", + "start_url": ".", + "display": "standalone", + "background_color": "#0175C2", + "theme_color": "#0175C2", + "description": "A new Flutter project.", + "orientation": "portrait-primary", + "prefer_related_applications": false, + "icons": [ + { + "src": "icons/Icon-192.png", + "sizes": "192x192", + "type": "image/png" + }, + { + "src": "icons/Icon-512.png", + "sizes": "512x512", + "type": "image/png" + }, + { + "src": "icons/Icon-maskable-192.png", + "sizes": "192x192", + "type": "image/png", + "purpose": "maskable" + }, + { + "src": "icons/Icon-maskable-512.png", + "sizes": "512x512", + "type": "image/png", + "purpose": "maskable" + } + ] +} diff --git a/gemini_tasks/windows/.gitignore b/gemini_tasks/windows/.gitignore new file mode 100644 index 00000000000..d492d0d98c8 --- /dev/null +++ b/gemini_tasks/windows/.gitignore @@ -0,0 +1,17 @@ +flutter/ephemeral/ + +# Visual Studio user-specific files. +*.suo +*.user +*.userosscache +*.sln.docstates + +# Visual Studio build-related files. +x64/ +x86/ + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ diff --git a/gemini_tasks/windows/CMakeLists.txt b/gemini_tasks/windows/CMakeLists.txt new file mode 100644 index 00000000000..1f6ab2448d1 --- /dev/null +++ b/gemini_tasks/windows/CMakeLists.txt @@ -0,0 +1,108 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.14) +project(gemini_tasks LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "gemini_tasks") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(VERSION 3.14...3.25) + +# Define build configuration option. +get_property(IS_MULTICONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +if(IS_MULTICONFIG) + set(CMAKE_CONFIGURATION_TYPES "Debug;Profile;Release" + CACHE STRING "" FORCE) +else() + if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") + endif() +endif() +# Define settings for the Profile build mode. +set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}") +set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}") +set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE}") +set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE}") + +# Use Unicode for all projects. +add_definitions(-DUNICODE -D_UNICODE) + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_17) + target_compile_options(${TARGET} PRIVATE /W4 /WX /wd"4100") + target_compile_options(${TARGET} PRIVATE /EHsc) + target_compile_definitions(${TARGET} PRIVATE "_HAS_EXCEPTIONS=0") + target_compile_definitions(${TARGET} PRIVATE "$<$:_DEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# Application build; see runner/CMakeLists.txt. +add_subdirectory("runner") + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# Support files are copied into place next to the executable, so that it can +# run in place. This is done instead of making a separate bundle (as on Linux) +# so that building and running from within Visual Studio will work. +set(BUILD_BUNDLE_DIR "$") +# Make the "install" step default, as it's required to run. +set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1) +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +if(PLUGIN_BUNDLED_LIBRARIES) + install(FILES "${PLUGIN_BUNDLED_LIBRARIES}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/windows/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + CONFIGURATIONS Profile;Release + COMPONENT Runtime) diff --git a/gemini_tasks/windows/flutter/CMakeLists.txt b/gemini_tasks/windows/flutter/CMakeLists.txt new file mode 100644 index 00000000000..903f4899d6f --- /dev/null +++ b/gemini_tasks/windows/flutter/CMakeLists.txt @@ -0,0 +1,109 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.14) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. +set(WRAPPER_ROOT "${EPHEMERAL_DIR}/cpp_client_wrapper") + +# Set fallback configurations for older versions of the flutter tool. +if (NOT DEFINED FLUTTER_TARGET_PLATFORM) + set(FLUTTER_TARGET_PLATFORM "windows-x64") +endif() + +# === Flutter Library === +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/flutter_windows.dll") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/windows/app.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "flutter_export.h" + "flutter_windows.h" + "flutter_messenger.h" + "flutter_plugin_registrar.h" + "flutter_texture_registrar.h" +) +list(TRANSFORM FLUTTER_LIBRARY_HEADERS PREPEND "${EPHEMERAL_DIR}/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}.lib") +add_dependencies(flutter flutter_assemble) + +# === Wrapper === +list(APPEND CPP_WRAPPER_SOURCES_CORE + "core_implementations.cc" + "standard_codec.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_CORE PREPEND "${WRAPPER_ROOT}/") +list(APPEND CPP_WRAPPER_SOURCES_PLUGIN + "plugin_registrar.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_PLUGIN PREPEND "${WRAPPER_ROOT}/") +list(APPEND CPP_WRAPPER_SOURCES_APP + "flutter_engine.cc" + "flutter_view_controller.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/") + +# Wrapper sources needed for a plugin. +add_library(flutter_wrapper_plugin STATIC + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_PLUGIN} +) +apply_standard_settings(flutter_wrapper_plugin) +set_target_properties(flutter_wrapper_plugin PROPERTIES + POSITION_INDEPENDENT_CODE ON) +set_target_properties(flutter_wrapper_plugin PROPERTIES + CXX_VISIBILITY_PRESET hidden) +target_link_libraries(flutter_wrapper_plugin PUBLIC flutter) +target_include_directories(flutter_wrapper_plugin PUBLIC + "${WRAPPER_ROOT}/include" +) +add_dependencies(flutter_wrapper_plugin flutter_assemble) + +# Wrapper sources needed for the runner. +add_library(flutter_wrapper_app STATIC + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_APP} +) +apply_standard_settings(flutter_wrapper_app) +target_link_libraries(flutter_wrapper_app PUBLIC flutter) +target_include_directories(flutter_wrapper_app PUBLIC + "${WRAPPER_ROOT}/include" +) +add_dependencies(flutter_wrapper_app flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +set(PHONY_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/_phony_") +set_source_files_properties("${PHONY_OUTPUT}" PROPERTIES SYMBOLIC TRUE) +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN} + ${CPP_WRAPPER_SOURCES_APP} + ${PHONY_OUTPUT} + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.bat" + ${FLUTTER_TARGET_PLATFORM} $ + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_PLUGIN} + ${CPP_WRAPPER_SOURCES_APP} +) diff --git a/gemini_tasks/windows/flutter/generated_plugin_registrant.cc b/gemini_tasks/windows/flutter/generated_plugin_registrant.cc new file mode 100644 index 00000000000..4f7884874da --- /dev/null +++ b/gemini_tasks/windows/flutter/generated_plugin_registrant.cc @@ -0,0 +1,14 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + +#include + +void RegisterPlugins(flutter::PluginRegistry* registry) { + UrlLauncherWindowsRegisterWithRegistrar( + registry->GetRegistrarForPlugin("UrlLauncherWindows")); +} diff --git a/gemini_tasks/windows/flutter/generated_plugin_registrant.h b/gemini_tasks/windows/flutter/generated_plugin_registrant.h new file mode 100644 index 00000000000..dc139d85a93 --- /dev/null +++ b/gemini_tasks/windows/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void RegisterPlugins(flutter::PluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/gemini_tasks/windows/flutter/generated_plugins.cmake b/gemini_tasks/windows/flutter/generated_plugins.cmake new file mode 100644 index 00000000000..88b22e5c775 --- /dev/null +++ b/gemini_tasks/windows/flutter/generated_plugins.cmake @@ -0,0 +1,24 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST + url_launcher_windows +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/windows plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/gemini_tasks/windows/runner/CMakeLists.txt b/gemini_tasks/windows/runner/CMakeLists.txt new file mode 100644 index 00000000000..394917c053a --- /dev/null +++ b/gemini_tasks/windows/runner/CMakeLists.txt @@ -0,0 +1,40 @@ +cmake_minimum_required(VERSION 3.14) +project(runner LANGUAGES CXX) + +# Define the application target. To change its name, change BINARY_NAME in the +# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer +# work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} WIN32 + "flutter_window.cpp" + "main.cpp" + "utils.cpp" + "win32_window.cpp" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" + "Runner.rc" + "runner.exe.manifest" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add preprocessor definitions for the build version. +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION=\"${FLUTTER_VERSION}\"") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MAJOR=${FLUTTER_VERSION_MAJOR}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MINOR=${FLUTTER_VERSION_MINOR}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_PATCH=${FLUTTER_VERSION_PATCH}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_BUILD=${FLUTTER_VERSION_BUILD}") + +# Disable Windows macros that collide with C++ standard library functions. +target_compile_definitions(${BINARY_NAME} PRIVATE "NOMINMAX") + +# Add dependency libraries and include directories. Add any application-specific +# dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter flutter_wrapper_app) +target_link_libraries(${BINARY_NAME} PRIVATE "dwmapi.lib") +target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}") + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) diff --git a/gemini_tasks/windows/runner/Runner.rc b/gemini_tasks/windows/runner/Runner.rc new file mode 100644 index 00000000000..bfa89d66659 --- /dev/null +++ b/gemini_tasks/windows/runner/Runner.rc @@ -0,0 +1,121 @@ +// Microsoft Visual C++ generated resource script. +// +#pragma code_page(65001) +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (United States) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_APP_ICON ICON "resources\\app_icon.ico" + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +#if defined(FLUTTER_VERSION_MAJOR) && defined(FLUTTER_VERSION_MINOR) && defined(FLUTTER_VERSION_PATCH) && defined(FLUTTER_VERSION_BUILD) +#define VERSION_AS_NUMBER FLUTTER_VERSION_MAJOR,FLUTTER_VERSION_MINOR,FLUTTER_VERSION_PATCH,FLUTTER_VERSION_BUILD +#else +#define VERSION_AS_NUMBER 1,0,0,0 +#endif + +#if defined(FLUTTER_VERSION) +#define VERSION_AS_STRING FLUTTER_VERSION +#else +#define VERSION_AS_STRING "1.0.0" +#endif + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VERSION_AS_NUMBER + PRODUCTVERSION VERSION_AS_NUMBER + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK +#ifdef _DEBUG + FILEFLAGS VS_FF_DEBUG +#else + FILEFLAGS 0x0L +#endif + FILEOS VOS__WINDOWS32 + FILETYPE VFT_APP + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904e4" + BEGIN + VALUE "CompanyName", "com.example" "\0" + VALUE "FileDescription", "gemini_tasks" "\0" + VALUE "FileVersion", VERSION_AS_STRING "\0" + VALUE "InternalName", "gemini_tasks" "\0" + VALUE "LegalCopyright", "Copyright (C) 2024 com.example. All rights reserved." "\0" + VALUE "OriginalFilename", "gemini_tasks.exe" "\0" + VALUE "ProductName", "gemini_tasks" "\0" + VALUE "ProductVersion", VERSION_AS_STRING "\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1252 + END +END + +#endif // English (United States) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED diff --git a/gemini_tasks/windows/runner/flutter_window.cpp b/gemini_tasks/windows/runner/flutter_window.cpp new file mode 100644 index 00000000000..955ee3038f9 --- /dev/null +++ b/gemini_tasks/windows/runner/flutter_window.cpp @@ -0,0 +1,71 @@ +#include "flutter_window.h" + +#include + +#include "flutter/generated_plugin_registrant.h" + +FlutterWindow::FlutterWindow(const flutter::DartProject& project) + : project_(project) {} + +FlutterWindow::~FlutterWindow() {} + +bool FlutterWindow::OnCreate() { + if (!Win32Window::OnCreate()) { + return false; + } + + RECT frame = GetClientArea(); + + // The size here must match the window dimensions to avoid unnecessary surface + // creation / destruction in the startup path. + flutter_controller_ = std::make_unique( + frame.right - frame.left, frame.bottom - frame.top, project_); + // Ensure that basic setup of the controller was successful. + if (!flutter_controller_->engine() || !flutter_controller_->view()) { + return false; + } + RegisterPlugins(flutter_controller_->engine()); + SetChildContent(flutter_controller_->view()->GetNativeWindow()); + + flutter_controller_->engine()->SetNextFrameCallback([&]() { + this->Show(); + }); + + // Flutter can complete the first frame before the "show window" callback is + // registered. The following call ensures a frame is pending to ensure the + // window is shown. It is a no-op if the first frame hasn't completed yet. + flutter_controller_->ForceRedraw(); + + return true; +} + +void FlutterWindow::OnDestroy() { + if (flutter_controller_) { + flutter_controller_ = nullptr; + } + + Win32Window::OnDestroy(); +} + +LRESULT +FlutterWindow::MessageHandler(HWND hwnd, UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + // Give Flutter, including plugins, an opportunity to handle window messages. + if (flutter_controller_) { + std::optional result = + flutter_controller_->HandleTopLevelWindowProc(hwnd, message, wparam, + lparam); + if (result) { + return *result; + } + } + + switch (message) { + case WM_FONTCHANGE: + flutter_controller_->engine()->ReloadSystemFonts(); + break; + } + + return Win32Window::MessageHandler(hwnd, message, wparam, lparam); +} diff --git a/gemini_tasks/windows/runner/flutter_window.h b/gemini_tasks/windows/runner/flutter_window.h new file mode 100644 index 00000000000..6da0652f05f --- /dev/null +++ b/gemini_tasks/windows/runner/flutter_window.h @@ -0,0 +1,33 @@ +#ifndef RUNNER_FLUTTER_WINDOW_H_ +#define RUNNER_FLUTTER_WINDOW_H_ + +#include +#include + +#include + +#include "win32_window.h" + +// A window that does nothing but host a Flutter view. +class FlutterWindow : public Win32Window { + public: + // Creates a new FlutterWindow hosting a Flutter view running |project|. + explicit FlutterWindow(const flutter::DartProject& project); + virtual ~FlutterWindow(); + + protected: + // Win32Window: + bool OnCreate() override; + void OnDestroy() override; + LRESULT MessageHandler(HWND window, UINT const message, WPARAM const wparam, + LPARAM const lparam) noexcept override; + + private: + // The project to run. + flutter::DartProject project_; + + // The Flutter instance hosted by this window. + std::unique_ptr flutter_controller_; +}; + +#endif // RUNNER_FLUTTER_WINDOW_H_ diff --git a/gemini_tasks/windows/runner/main.cpp b/gemini_tasks/windows/runner/main.cpp new file mode 100644 index 00000000000..88476d2d09a --- /dev/null +++ b/gemini_tasks/windows/runner/main.cpp @@ -0,0 +1,43 @@ +#include +#include +#include + +#include "flutter_window.h" +#include "utils.h" + +int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev, + _In_ wchar_t *command_line, _In_ int show_command) { + // Attach to console when present (e.g., 'flutter run') or create a + // new console when running with a debugger. + if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) { + CreateAndAttachConsole(); + } + + // Initialize COM, so that it is available for use in the library and/or + // plugins. + ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED); + + flutter::DartProject project(L"data"); + + std::vector command_line_arguments = + GetCommandLineArguments(); + + project.set_dart_entrypoint_arguments(std::move(command_line_arguments)); + + FlutterWindow window(project); + Win32Window::Point origin(10, 10); + Win32Window::Size size(1280, 720); + if (!window.Create(L"gemini_tasks", origin, size)) { + return EXIT_FAILURE; + } + window.SetQuitOnClose(true); + + ::MSG msg; + while (::GetMessage(&msg, nullptr, 0, 0)) { + ::TranslateMessage(&msg); + ::DispatchMessage(&msg); + } + + ::CoUninitialize(); + return EXIT_SUCCESS; +} diff --git a/gemini_tasks/windows/runner/resource.h b/gemini_tasks/windows/runner/resource.h new file mode 100644 index 00000000000..66a65d1e4a7 --- /dev/null +++ b/gemini_tasks/windows/runner/resource.h @@ -0,0 +1,16 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by Runner.rc +// +#define IDI_APP_ICON 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 102 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/gemini_tasks/windows/runner/resources/app_icon.ico b/gemini_tasks/windows/runner/resources/app_icon.ico new file mode 100644 index 00000000000..c04e20caf63 Binary files /dev/null and b/gemini_tasks/windows/runner/resources/app_icon.ico differ diff --git a/gemini_tasks/windows/runner/runner.exe.manifest b/gemini_tasks/windows/runner/runner.exe.manifest new file mode 100644 index 00000000000..a42ea7687cb --- /dev/null +++ b/gemini_tasks/windows/runner/runner.exe.manifest @@ -0,0 +1,20 @@ + + + + + PerMonitorV2 + + + + + + + + + + + + + + + diff --git a/gemini_tasks/windows/runner/utils.cpp b/gemini_tasks/windows/runner/utils.cpp new file mode 100644 index 00000000000..b2b08734db2 --- /dev/null +++ b/gemini_tasks/windows/runner/utils.cpp @@ -0,0 +1,65 @@ +#include "utils.h" + +#include +#include +#include +#include + +#include + +void CreateAndAttachConsole() { + if (::AllocConsole()) { + FILE *unused; + if (freopen_s(&unused, "CONOUT$", "w", stdout)) { + _dup2(_fileno(stdout), 1); + } + if (freopen_s(&unused, "CONOUT$", "w", stderr)) { + _dup2(_fileno(stdout), 2); + } + std::ios::sync_with_stdio(); + FlutterDesktopResyncOutputStreams(); + } +} + +std::vector GetCommandLineArguments() { + // Convert the UTF-16 command line arguments to UTF-8 for the Engine to use. + int argc; + wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc); + if (argv == nullptr) { + return std::vector(); + } + + std::vector command_line_arguments; + + // Skip the first argument as it's the binary name. + for (int i = 1; i < argc; i++) { + command_line_arguments.push_back(Utf8FromUtf16(argv[i])); + } + + ::LocalFree(argv); + + return command_line_arguments; +} + +std::string Utf8FromUtf16(const wchar_t* utf16_string) { + if (utf16_string == nullptr) { + return std::string(); + } + int target_length = ::WideCharToMultiByte( + CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, + -1, nullptr, 0, nullptr, nullptr) + -1; // remove the trailing null character + int input_length = (int)wcslen(utf16_string); + std::string utf8_string; + if (target_length <= 0 || target_length > utf8_string.max_size()) { + return utf8_string; + } + utf8_string.resize(target_length); + int converted_length = ::WideCharToMultiByte( + CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, + input_length, utf8_string.data(), target_length, nullptr, nullptr); + if (converted_length == 0) { + return std::string(); + } + return utf8_string; +} diff --git a/gemini_tasks/windows/runner/utils.h b/gemini_tasks/windows/runner/utils.h new file mode 100644 index 00000000000..3879d547557 --- /dev/null +++ b/gemini_tasks/windows/runner/utils.h @@ -0,0 +1,19 @@ +#ifndef RUNNER_UTILS_H_ +#define RUNNER_UTILS_H_ + +#include +#include + +// Creates a console for the process, and redirects stdout and stderr to +// it for both the runner and the Flutter library. +void CreateAndAttachConsole(); + +// Takes a null-terminated wchar_t* encoded in UTF-16 and returns a std::string +// encoded in UTF-8. Returns an empty std::string on failure. +std::string Utf8FromUtf16(const wchar_t* utf16_string); + +// Gets the command line arguments passed in as a std::vector, +// encoded in UTF-8. Returns an empty std::vector on failure. +std::vector GetCommandLineArguments(); + +#endif // RUNNER_UTILS_H_ diff --git a/gemini_tasks/windows/runner/win32_window.cpp b/gemini_tasks/windows/runner/win32_window.cpp new file mode 100644 index 00000000000..60608d0fe5b --- /dev/null +++ b/gemini_tasks/windows/runner/win32_window.cpp @@ -0,0 +1,288 @@ +#include "win32_window.h" + +#include +#include + +#include "resource.h" + +namespace { + +/// Window attribute that enables dark mode window decorations. +/// +/// Redefined in case the developer's machine has a Windows SDK older than +/// version 10.0.22000.0. +/// See: https://docs.microsoft.com/windows/win32/api/dwmapi/ne-dwmapi-dwmwindowattribute +#ifndef DWMWA_USE_IMMERSIVE_DARK_MODE +#define DWMWA_USE_IMMERSIVE_DARK_MODE 20 +#endif + +constexpr const wchar_t kWindowClassName[] = L"FLUTTER_RUNNER_WIN32_WINDOW"; + +/// Registry key for app theme preference. +/// +/// A value of 0 indicates apps should use dark mode. A non-zero or missing +/// value indicates apps should use light mode. +constexpr const wchar_t kGetPreferredBrightnessRegKey[] = + L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize"; +constexpr const wchar_t kGetPreferredBrightnessRegValue[] = L"AppsUseLightTheme"; + +// The number of Win32Window objects that currently exist. +static int g_active_window_count = 0; + +using EnableNonClientDpiScaling = BOOL __stdcall(HWND hwnd); + +// Scale helper to convert logical scaler values to physical using passed in +// scale factor +int Scale(int source, double scale_factor) { + return static_cast(source * scale_factor); +} + +// Dynamically loads the |EnableNonClientDpiScaling| from the User32 module. +// This API is only needed for PerMonitor V1 awareness mode. +void EnableFullDpiSupportIfAvailable(HWND hwnd) { + HMODULE user32_module = LoadLibraryA("User32.dll"); + if (!user32_module) { + return; + } + auto enable_non_client_dpi_scaling = + reinterpret_cast( + GetProcAddress(user32_module, "EnableNonClientDpiScaling")); + if (enable_non_client_dpi_scaling != nullptr) { + enable_non_client_dpi_scaling(hwnd); + } + FreeLibrary(user32_module); +} + +} // namespace + +// Manages the Win32Window's window class registration. +class WindowClassRegistrar { + public: + ~WindowClassRegistrar() = default; + + // Returns the singleton registrar instance. + static WindowClassRegistrar* GetInstance() { + if (!instance_) { + instance_ = new WindowClassRegistrar(); + } + return instance_; + } + + // Returns the name of the window class, registering the class if it hasn't + // previously been registered. + const wchar_t* GetWindowClass(); + + // Unregisters the window class. Should only be called if there are no + // instances of the window. + void UnregisterWindowClass(); + + private: + WindowClassRegistrar() = default; + + static WindowClassRegistrar* instance_; + + bool class_registered_ = false; +}; + +WindowClassRegistrar* WindowClassRegistrar::instance_ = nullptr; + +const wchar_t* WindowClassRegistrar::GetWindowClass() { + if (!class_registered_) { + WNDCLASS window_class{}; + window_class.hCursor = LoadCursor(nullptr, IDC_ARROW); + window_class.lpszClassName = kWindowClassName; + window_class.style = CS_HREDRAW | CS_VREDRAW; + window_class.cbClsExtra = 0; + window_class.cbWndExtra = 0; + window_class.hInstance = GetModuleHandle(nullptr); + window_class.hIcon = + LoadIcon(window_class.hInstance, MAKEINTRESOURCE(IDI_APP_ICON)); + window_class.hbrBackground = 0; + window_class.lpszMenuName = nullptr; + window_class.lpfnWndProc = Win32Window::WndProc; + RegisterClass(&window_class); + class_registered_ = true; + } + return kWindowClassName; +} + +void WindowClassRegistrar::UnregisterWindowClass() { + UnregisterClass(kWindowClassName, nullptr); + class_registered_ = false; +} + +Win32Window::Win32Window() { + ++g_active_window_count; +} + +Win32Window::~Win32Window() { + --g_active_window_count; + Destroy(); +} + +bool Win32Window::Create(const std::wstring& title, + const Point& origin, + const Size& size) { + Destroy(); + + const wchar_t* window_class = + WindowClassRegistrar::GetInstance()->GetWindowClass(); + + const POINT target_point = {static_cast(origin.x), + static_cast(origin.y)}; + HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST); + UINT dpi = FlutterDesktopGetDpiForMonitor(monitor); + double scale_factor = dpi / 96.0; + + HWND window = CreateWindow( + window_class, title.c_str(), WS_OVERLAPPEDWINDOW, + Scale(origin.x, scale_factor), Scale(origin.y, scale_factor), + Scale(size.width, scale_factor), Scale(size.height, scale_factor), + nullptr, nullptr, GetModuleHandle(nullptr), this); + + if (!window) { + return false; + } + + UpdateTheme(window); + + return OnCreate(); +} + +bool Win32Window::Show() { + return ShowWindow(window_handle_, SW_SHOWNORMAL); +} + +// static +LRESULT CALLBACK Win32Window::WndProc(HWND const window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + if (message == WM_NCCREATE) { + auto window_struct = reinterpret_cast(lparam); + SetWindowLongPtr(window, GWLP_USERDATA, + reinterpret_cast(window_struct->lpCreateParams)); + + auto that = static_cast(window_struct->lpCreateParams); + EnableFullDpiSupportIfAvailable(window); + that->window_handle_ = window; + } else if (Win32Window* that = GetThisFromHandle(window)) { + return that->MessageHandler(window, message, wparam, lparam); + } + + return DefWindowProc(window, message, wparam, lparam); +} + +LRESULT +Win32Window::MessageHandler(HWND hwnd, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + switch (message) { + case WM_DESTROY: + window_handle_ = nullptr; + Destroy(); + if (quit_on_close_) { + PostQuitMessage(0); + } + return 0; + + case WM_DPICHANGED: { + auto newRectSize = reinterpret_cast(lparam); + LONG newWidth = newRectSize->right - newRectSize->left; + LONG newHeight = newRectSize->bottom - newRectSize->top; + + SetWindowPos(hwnd, nullptr, newRectSize->left, newRectSize->top, newWidth, + newHeight, SWP_NOZORDER | SWP_NOACTIVATE); + + return 0; + } + case WM_SIZE: { + RECT rect = GetClientArea(); + if (child_content_ != nullptr) { + // Size and position the child window. + MoveWindow(child_content_, rect.left, rect.top, rect.right - rect.left, + rect.bottom - rect.top, TRUE); + } + return 0; + } + + case WM_ACTIVATE: + if (child_content_ != nullptr) { + SetFocus(child_content_); + } + return 0; + + case WM_DWMCOLORIZATIONCOLORCHANGED: + UpdateTheme(hwnd); + return 0; + } + + return DefWindowProc(window_handle_, message, wparam, lparam); +} + +void Win32Window::Destroy() { + OnDestroy(); + + if (window_handle_) { + DestroyWindow(window_handle_); + window_handle_ = nullptr; + } + if (g_active_window_count == 0) { + WindowClassRegistrar::GetInstance()->UnregisterWindowClass(); + } +} + +Win32Window* Win32Window::GetThisFromHandle(HWND const window) noexcept { + return reinterpret_cast( + GetWindowLongPtr(window, GWLP_USERDATA)); +} + +void Win32Window::SetChildContent(HWND content) { + child_content_ = content; + SetParent(content, window_handle_); + RECT frame = GetClientArea(); + + MoveWindow(content, frame.left, frame.top, frame.right - frame.left, + frame.bottom - frame.top, true); + + SetFocus(child_content_); +} + +RECT Win32Window::GetClientArea() { + RECT frame; + GetClientRect(window_handle_, &frame); + return frame; +} + +HWND Win32Window::GetHandle() { + return window_handle_; +} + +void Win32Window::SetQuitOnClose(bool quit_on_close) { + quit_on_close_ = quit_on_close; +} + +bool Win32Window::OnCreate() { + // No-op; provided for subclasses. + return true; +} + +void Win32Window::OnDestroy() { + // No-op; provided for subclasses. +} + +void Win32Window::UpdateTheme(HWND const window) { + DWORD light_mode; + DWORD light_mode_size = sizeof(light_mode); + LSTATUS result = RegGetValue(HKEY_CURRENT_USER, kGetPreferredBrightnessRegKey, + kGetPreferredBrightnessRegValue, + RRF_RT_REG_DWORD, nullptr, &light_mode, + &light_mode_size); + + if (result == ERROR_SUCCESS) { + BOOL enable_dark_mode = light_mode == 0; + DwmSetWindowAttribute(window, DWMWA_USE_IMMERSIVE_DARK_MODE, + &enable_dark_mode, sizeof(enable_dark_mode)); + } +} diff --git a/gemini_tasks/windows/runner/win32_window.h b/gemini_tasks/windows/runner/win32_window.h new file mode 100644 index 00000000000..e901dde684e --- /dev/null +++ b/gemini_tasks/windows/runner/win32_window.h @@ -0,0 +1,102 @@ +#ifndef RUNNER_WIN32_WINDOW_H_ +#define RUNNER_WIN32_WINDOW_H_ + +#include + +#include +#include +#include + +// A class abstraction for a high DPI-aware Win32 Window. Intended to be +// inherited from by classes that wish to specialize with custom +// rendering and input handling +class Win32Window { + public: + struct Point { + unsigned int x; + unsigned int y; + Point(unsigned int x, unsigned int y) : x(x), y(y) {} + }; + + struct Size { + unsigned int width; + unsigned int height; + Size(unsigned int width, unsigned int height) + : width(width), height(height) {} + }; + + Win32Window(); + virtual ~Win32Window(); + + // Creates a win32 window with |title| that is positioned and sized using + // |origin| and |size|. New windows are created on the default monitor. Window + // sizes are specified to the OS in physical pixels, hence to ensure a + // consistent size this function will scale the inputted width and height as + // as appropriate for the default monitor. The window is invisible until + // |Show| is called. Returns true if the window was created successfully. + bool Create(const std::wstring& title, const Point& origin, const Size& size); + + // Show the current window. Returns true if the window was successfully shown. + bool Show(); + + // Release OS resources associated with window. + void Destroy(); + + // Inserts |content| into the window tree. + void SetChildContent(HWND content); + + // Returns the backing Window handle to enable clients to set icon and other + // window properties. Returns nullptr if the window has been destroyed. + HWND GetHandle(); + + // If true, closing this window will quit the application. + void SetQuitOnClose(bool quit_on_close); + + // Return a RECT representing the bounds of the current client area. + RECT GetClientArea(); + + protected: + // Processes and route salient window messages for mouse handling, + // size change and DPI. Delegates handling of these to member overloads that + // inheriting classes can handle. + virtual LRESULT MessageHandler(HWND window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept; + + // Called when CreateAndShow is called, allowing subclass window-related + // setup. Subclasses should return false if setup fails. + virtual bool OnCreate(); + + // Called when Destroy is called. + virtual void OnDestroy(); + + private: + friend class WindowClassRegistrar; + + // OS callback called by message pump. Handles the WM_NCCREATE message which + // is passed when the non-client area is being created and enables automatic + // non-client DPI scaling so that the non-client area automatically + // responds to changes in DPI. All other messages are handled by + // MessageHandler. + static LRESULT CALLBACK WndProc(HWND const window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept; + + // Retrieves a class instance pointer for |window| + static Win32Window* GetThisFromHandle(HWND const window) noexcept; + + // Update the window frame's theme to match the system theme. + static void UpdateTheme(HWND const window); + + bool quit_on_close_ = false; + + // window handle for top level window. + HWND window_handle_ = nullptr; + + // window handle for hosted content. + HWND child_content_ = nullptr; +}; + +#endif // RUNNER_WIN32_WINDOW_H_ diff --git a/tool/flutter_ci_script_beta.sh b/tool/flutter_ci_script_beta.sh index f137d63ee31..556c7507120 100755 --- a/tool/flutter_ci_script_beta.sh +++ b/tool/flutter_ci_script_beta.sh @@ -25,6 +25,8 @@ declare -ar PROJECT_NAMES=( "deeplink_store_example" "desktop_photo_search/fluent_ui" "desktop_photo_search/material" + # TODO: 'surfaceVariant' is deprecated and shouldn't be used. + # "dynamic_theme" "experimental/federated_plugin/federated_plugin" "experimental/federated_plugin/federated_plugin/example" "experimental/federated_plugin/federated_plugin_macos" @@ -33,7 +35,7 @@ declare -ar PROJECT_NAMES=( "experimental/federated_plugin/federated_plugin_windows" # TODO: ewindmill to talk to team about removing. # Depends on package context_menus, which breaks with Material3 by default. -# "experimental/linting_tool" + # "experimental/linting_tool" "experimental/pedometer" "experimental/pedometer/example" "experimental/varfont_shader_puzzle" @@ -41,6 +43,10 @@ declare -ar PROJECT_NAMES=( "flutter_maps_firestore" "form_app" "game_template" + # TODO: 'onBackground' is deprecated and shouldn't be used. + # "game_template" + # TODO: 'surfaceVariant' is deprecated and shouldn't be used. + # "gemini_tasks" "google_maps" "infinite_list" "ios_app_clip" diff --git a/tool/flutter_ci_script_stable.sh b/tool/flutter_ci_script_stable.sh index 72a14c91738..599a46ee350 100755 --- a/tool/flutter_ci_script_stable.sh +++ b/tool/flutter_ci_script_stable.sh @@ -25,6 +25,7 @@ declare -ar PROJECT_NAMES=( "deeplink_store_example" "desktop_photo_search/fluent_ui" "desktop_photo_search/material" + "dynamic_theme" "experimental/federated_plugin/federated_plugin" "experimental/federated_plugin/federated_plugin/example" "experimental/federated_plugin/federated_plugin_macos" @@ -41,6 +42,7 @@ declare -ar PROJECT_NAMES=( "flutter_maps_firestore" "form_app" "game_template" + "gemini_tasks" "google_maps" "infinite_list" "ios_app_clip" diff --git a/web/_tool/pubspec.yaml b/web/_tool/pubspec.yaml index f2bb6b2d026..93963af61a2 100644 --- a/web/_tool/pubspec.yaml +++ b/web/_tool/pubspec.yaml @@ -9,4 +9,4 @@ dependencies: path: ^1.8.0 dev_dependencies: - lints: ^3.0.0 + lints: ^4.0.0 diff --git a/web/samples_index/pubspec.yaml b/web/samples_index/pubspec.yaml index d5daa99b878..dc1b8acd82b 100644 --- a/web/samples_index/pubspec.yaml +++ b/web/samples_index/pubspec.yaml @@ -22,7 +22,7 @@ dev_dependencies: grinder: ^0.9.4 image: ^4.1.3 json_serializable: ^6.6.2 - lints: ^3.0.0 + lints: ^4.0.0 test: ^1.24.2 # package:mdc_web needs to upgrade the version of material-components-web 12.0.0 diff --git a/web_embedding/element_embedding_demo/pubspec.yaml b/web_embedding/element_embedding_demo/pubspec.yaml index 52e0b9cd294..a2f0e709180 100644 --- a/web_embedding/element_embedding_demo/pubspec.yaml +++ b/web_embedding/element_embedding_demo/pubspec.yaml @@ -14,7 +14,7 @@ dependencies: dev_dependencies: flutter_test: sdk: flutter - flutter_lints: ^3.0.0 + flutter_lints: ^4.0.0 flutter: uses-material-design: true diff --git a/web_embedding/ng-flutter/flutter/pubspec.yaml b/web_embedding/ng-flutter/flutter/pubspec.yaml index 6f4e7945c14..b1d74497420 100644 --- a/web_embedding/ng-flutter/flutter/pubspec.yaml +++ b/web_embedding/ng-flutter/flutter/pubspec.yaml @@ -15,7 +15,7 @@ dependencies: dev_dependencies: flutter_test: sdk: flutter - flutter_lints: ^3.0.0 + flutter_lints: ^4.0.0 flutter: uses-material-design: true