Repository: okadan/flutter-nfc-manager
Branch: main
Commit: 262451431578
Files: 92
Total size: 510.8 KB
Directory structure:
gitextract_7nrhxl8x/
├── .gitignore
├── .metadata
├── CHANGELOG.md
├── LICENSE
├── README.md
├── analysis_options.yaml
├── android/
│ ├── .gitignore
│ ├── build.gradle.kts
│ ├── settings.gradle
│ ├── settings.gradle.kts
│ └── src/
│ ├── main/
│ │ ├── AndroidManifest.xml
│ │ └── kotlin/
│ │ └── dev/
│ │ └── flutter/
│ │ └── plugins/
│ │ └── nfcmanager/
│ │ ├── NfcManagerPlugin.kt
│ │ └── Pigeon.kt
│ └── test/
│ └── kotlin/
│ └── dev/
│ └── flutter/
│ └── plugins/
│ └── nfcmanager/
│ └── NfcManagerPluginTest.kt
├── example/
│ ├── .gitignore
│ ├── README.md
│ ├── analysis_options.yaml
│ ├── android/
│ │ ├── .gitignore
│ │ ├── app/
│ │ │ ├── build.gradle.kts
│ │ │ └── src/
│ │ │ ├── debug/
│ │ │ │ └── AndroidManifest.xml
│ │ │ ├── main/
│ │ │ │ ├── AndroidManifest.xml
│ │ │ │ ├── kotlin/
│ │ │ │ │ └── dev/
│ │ │ │ │ └── flutter/
│ │ │ │ │ └── plugins/
│ │ │ │ │ └── nfcmanagerexample/
│ │ │ │ │ └── MainActivity.kt
│ │ │ │ └── res/
│ │ │ │ ├── drawable/
│ │ │ │ │ └── launch_background.xml
│ │ │ │ ├── drawable-v21/
│ │ │ │ │ └── launch_background.xml
│ │ │ │ ├── values/
│ │ │ │ │ └── styles.xml
│ │ │ │ └── values-night/
│ │ │ │ └── styles.xml
│ │ │ └── profile/
│ │ │ └── AndroidManifest.xml
│ │ ├── build.gradle.kts
│ │ ├── gradle/
│ │ │ └── wrapper/
│ │ │ └── gradle-wrapper.properties
│ │ ├── gradle.properties
│ │ └── settings.gradle.kts
│ ├── ios/
│ │ ├── .gitignore
│ │ ├── Flutter/
│ │ │ ├── AppFrameworkInfo.plist
│ │ │ ├── Debug.xcconfig
│ │ │ └── Release.xcconfig
│ │ ├── Runner/
│ │ │ ├── AppDelegate.swift
│ │ │ ├── Assets.xcassets/
│ │ │ │ ├── AppIcon.appiconset/
│ │ │ │ │ └── Contents.json
│ │ │ │ └── LaunchImage.imageset/
│ │ │ │ ├── Contents.json
│ │ │ │ └── README.md
│ │ │ ├── Base.lproj/
│ │ │ │ ├── LaunchScreen.storyboard
│ │ │ │ └── Main.storyboard
│ │ │ ├── Info.plist
│ │ │ ├── Runner-Bridging-Header.h
│ │ │ └── SceneDelegate.swift
│ │ ├── Runner.xcodeproj/
│ │ │ ├── project.pbxproj
│ │ │ ├── project.xcworkspace/
│ │ │ │ ├── contents.xcworkspacedata
│ │ │ │ └── xcshareddata/
│ │ │ │ ├── IDEWorkspaceChecks.plist
│ │ │ │ └── WorkspaceSettings.xcsettings
│ │ │ └── xcshareddata/
│ │ │ └── xcschemes/
│ │ │ └── Runner.xcscheme
│ │ ├── Runner.xcworkspace/
│ │ │ ├── contents.xcworkspacedata
│ │ │ └── xcshareddata/
│ │ │ ├── IDEWorkspaceChecks.plist
│ │ │ └── WorkspaceSettings.xcsettings
│ │ └── RunnerTests/
│ │ └── RunnerTests.swift
│ ├── lib/
│ │ └── main.dart
│ └── pubspec.yaml
├── ios/
│ ├── .gitignore
│ ├── nfc_manager/
│ │ ├── Package.swift
│ │ └── Sources/
│ │ └── nfc_manager/
│ │ ├── NfcManagerPlugin.swift
│ │ └── Pigeon.swift
│ └── nfc_manager.podspec
├── lib/
│ ├── ndef_record.dart
│ ├── nfc_manager.dart
│ ├── nfc_manager_android.dart
│ ├── nfc_manager_ios.dart
│ └── src/
│ ├── nfc_manager/
│ │ └── nfc_manager.dart
│ ├── nfc_manager_android/
│ │ ├── nfc_manager.dart
│ │ ├── nfc_manager_platform.dart
│ │ ├── pigeon.dart
│ │ ├── pigeon.g.dart
│ │ └── tags/
│ │ ├── iso_dep.dart
│ │ ├── mifare_classic.dart
│ │ ├── mifare_ultralight.dart
│ │ ├── ndef.dart
│ │ ├── ndef_formatable.dart
│ │ ├── nfc_a.dart
│ │ ├── nfc_b.dart
│ │ ├── nfc_barcode.dart
│ │ ├── nfc_f.dart
│ │ ├── nfc_v.dart
│ │ └── tag.dart
│ └── nfc_manager_ios/
│ ├── nfc_manager.dart
│ ├── nfc_manager_platform.dart
│ ├── pigeon.dart
│ ├── pigeon.g.dart
│ └── tags/
│ ├── felica.dart
│ ├── iso15693.dart
│ ├── iso7816.dart
│ ├── mifare.dart
│ └── ndef.dart
├── pigeon/
│ ├── android.dart
│ └── ios.dart
└── pubspec.yaml
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# Miscellaneous
*.class
*.log
*.pyc
*.swp
.DS_Store
.atom/
.build/
.buildlog/
.history
.svn/
.swiftpm/
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
# Libraries should not include pubspec.lock, per https://dart.dev/guides/libraries/private-files#pubspeclock.
/pubspec.lock
**/doc/api/
.dart_tool/
.flutter-plugins-dependencies
/build/
/coverage/
================================================
FILE: .metadata
================================================
# 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: "db50e20168db8fee486b9abf32fc912de3bc5b6a"
channel: "stable"
project_type: plugin
# Tracks metadata for the flutter migrate command
migration:
platforms:
- platform: root
create_revision: db50e20168db8fee486b9abf32fc912de3bc5b6a
base_revision: db50e20168db8fee486b9abf32fc912de3bc5b6a
- platform: android
create_revision: db50e20168db8fee486b9abf32fc912de3bc5b6a
base_revision: db50e20168db8fee486b9abf32fc912de3bc5b6a
- platform: ios
create_revision: db50e20168db8fee486b9abf32fc912de3bc5b6a
base_revision: db50e20168db8fee486b9abf32fc912de3bc5b6a
# 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'
================================================
FILE: CHANGELOG.md
================================================
## 4.2.0
* Add Swift Package Manager support.
* Bump dependencies.
## 4.1.1
* Avoid iOS SDK version constraints caused by the addition of `NFCReaderError.Code`.
## 4.1.0
* Deprecated `NfcManager#isAvailable`. Use `NfcManager#checkAvailability` instead.
* Fix iOS background issue.
* Add more `NFCReaderError.Code` for iOS.
* Bump versions.
* Update doc.
## 4.0.2
* Update README.
## 4.0.1
* Update package page.
## 4.0.0
**Has many breaking changes.**
* Rename the following:
* `NfcA` to `NfcAAndroid`
* `NfcB` to `NfcBAndroid`
* `NfcF` to `NfcFAndroid`
* `NfcV` to `NfcVAndroid`
* `IsoDep` to `IsoDepAndroid`
* `MifareClassic` to `MifareClassicAndroid`
* `MifareUltralight` to `MifareUltralightAndroid`
* `NdefFormatable` to `NdefFormatableAndroid`
* `MiFare` to `MiFareIos`
* `FeliCa` to `FeliCaIos`
* `Iso15693` to `Iso15693Ios`
* `Iso7816` to `Iso7816Ios`
* Options for `startSession`:
* `onError` to `onErrorIos`
* `invalidateAfterFirstRead` to `invalidateAfterFirstReadIos`
* `alertMessage` to `alertMessageIos`
* Options for `stopSession`:
* `alertMessage` to `alertMessageIos`
* `errorMessage` to `errorMessageIos`
* Remove the following:
* `Ndef` (Instead use the [`nfc_manager_ndef`](https://pub.dev/packages/nfc_manager_ndef) package or `NdefAndroid` / `NdefIos`)
* `timeout` (Instead use the `async getTimeout()` method)
* `maxTransceiveLength` (Instead use the `async getMaxTransceiveLength()` method)
* `NfcError` (Instead use the `NfcReaderSessionErrorIos`)
* `NfcErrorType` (Instead use the `NfcReaderErrorCodeIos`)
* Add the following:
* `ndef_record.dart` library that provides access to [`ndef_record`](https://pub.dev/packages/ndef_record) package.
* `nfc_manager_android.dart` library that provides access to Android API.
* `nfc_manager_ios.dart` library that provides access to iOS API.
* `async setTimeout()` method.
* `noPlatformSoundsAndroid` option to `startSession` method.
* Upgrade Flutter.
* Update README.
## 3.5.1
* Make compatible for Kotlin 2.1.0
## 3.5.0
* Upgrade Flutter.
* Fix analyze issues.
## 3.4.0
* Fix iOS background isolate issue.
* Add namespace to Gradle for Android.
* Rebuild projects on Flutter stable channel.
## 3.3.0
* Added `invalidateAfterFirstRead` argument to `startSession`. This enables `restartPolling` on iOS.
## 3.2.0
* Fix build issues.
## 3.1.1
* Upgrade kotlin version.
## 3.1.0
* Fix Null-Safety related issues. The following properties are now nullable.
* `IsoDep#hiLayerResponse`
* `IsoDep#historicalBytes`
* `Iso7816#historicalBytes`
* `Iso7816#applicationData`
* `MiFare#historicalBytes`
## 3.0.0+2
* Update doc.
## 3.0.0+1
* Flutter format.
## 3.0.0
* Upgrade to null safety.
## 2.0.3
* Fix type conversion errors in `FeliCa#readWithoutEncryption` and `FeliCa#requestServiceV2`.
## 2.0.2
* Fix a bug in calling `FeliCa.sendFeliCaCommand` method.
## 2.0.1+1
* Update README.
## 2.0.1
* Fix an error when initializing plugin for non-NFC Android devices.
## 2.0.0+2
* Update doc.
* Flutter format.
## 2.0.0+1
* Update doc.
## 2.0.0
**Has many breaking changes.**
* Remove `startNdefSession` and `NdefDiscoveredCallback`.
* Rename `startTagSession` to `startSession`.
* Rename `TagPollingOption` to `NfcPollingOption`.
* Rename `NfcSessionError` to `NfcError`.
* Rename `NfcSessionErrorType` to `NfcErrorType`.
* Rename `TagDiscoveredCallback` to `NfcTagCallback`.
* Rename `NfcSessionErrorCallback` to `NfcErrorCallback`.
* Rename `ISO15693` to `Iso15693`.
* Rename `ISO7816` to `Iso7816`.
* Rename `fromTag` to `from`. (e.g. `MiFare.fromTag(tag)` -> `MiFare.from(tag)`)
* Add `NdefTypeNameFormat` enum.
* Add `NdefFormatable`, `MifareClassic` and `MifareUltralight` classes.
* Add `Ndef#read` method.
* Add command-implementations for `FeliCa` and `Iso15693`.
* Upgrade flutter environment.
## 1.3.2+4
* Update README.
## 1.3.2+3
* Update README.
## 1.3.2+2
* Update README.
## 1.3.2+1
* Update README.
## 1.3.2
* Fix crash on Ndef write and writeLock error.
## 1.3.1
* Fix a bug where the error callback was not called.
## 1.3.0
* Add callback to handle error from session.
## 1.2.0
* Make discovered callback async.
## 1.1.0+1
* Update readme.
## 1.1.0
* Add constants.
* Fix misspelled name.
* Fix xcode build warning.
* Increase the Flutter SDK requirement to ^1.10.0.
## 1.0.1
* Fix error on invoking transceive method.
## 1.0.0
* Add platform-specifc-tag operations.
* Remove `NfcSessionType` enum.
* Migrate to pubspec platforms manifest.
* More consistent naming.
## 0.5.1
* Update flutter project files.
* Additional fix for migration to AndroidX.
## 0.5.0
* Migrate to AndroidX.
## 0.4.0+2
* Fix typo on README
## 0.4.0+1
* Update README
## 0.4.0
* Rename `NfcNdef#cachedNdef` to `NfcNdef#cachedMessage`.
* Add `NfcSessionType` enum.
* Add `NfcTagPollingOption` enum.
## 0.3.0
* Add `NdefRecord#createMimeRecord`.
* Add optional parameters `alertMessageIOS` and `errorMessageIOS` displayed in iOS system UI.
* Fix error on deserializing null message on dart side.
## 0.2.0
* Split `startSession` into `startNdefSession` and `startTagSession`.
* Improve doc.
## 0.1.1
* Fix crash on serializing nil message on ios side.
* Add example project.
* Improve doc.
## 0.1.0+2
* Improve doc.
## 0.1.0+1
* Improve doc.
## 0.1.0
* Add iOS 13 features.
## 0.0.1
* Initial release.
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2019 okadan
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# nfc_manager
A Flutter plugin providing access to NFC features on Android and iOS.
## Setup
### Android
* Add [android.permission.NFC](https://developer.android.com/reference/android/Manifest.permission.html#NFC) to your `AndroidManifest.xml`.
### iOS
* Add [Near Field Communication Tag Reader Session Formats Entitlements](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_developer_nfc_readersession_formats) to your entitlements.
* Add [NFCReaderUsageDescription](https://developer.apple.com/documentation/bundleresources/information_property_list/nfcreaderusagedescription) to your `Info.plist`.
* Add [com.apple.developer.nfc.readersession.iso7816.select-identifiers](https://developer.apple.com/documentation/bundleresources/information_property_list/select-identifiers) to your `Info.plist` as needed.
* Add [com.apple.developer.nfc.readersession.felica.systemcodes](https://developer.apple.com/documentation/bundleresources/information_property_list/systemcodes) to your `Info.plist` if you specify `NfcPollingOption.iso18092` in `startSession`, otherwise an error will occur.
## Usage
### Handling the Session
```dart
import 'package:nfc_manager/nfc_manager.dart';
// Check the availability of NFC on the current device.
NfcAvailability availability = await NfcManager.instance.checkAvailability();
if (availability != NfcAvailability.enabled) {
print('NFC may not be supported or may be temporarily disabled.');
return;
}
// Start the session.
NfcManager.instance.startSession(
pollingOptions: {NfcPollingOption.iso14443}, // You can also specify iso18092 and iso15693.
onDiscovered: (NfcTag tag) async {
// Do something with an NfcTag instance...
print(tag);
// Stop the session when no longer needed.
await NfcManager.instance.stopSession();
},
);
```
### Working with NfcTag
An `NfcTag` instance is typically not used directly. Instead, convert it to a platform-specific tag class by calling that class's static method `from`.
```dart
import 'package:nfc_manager/nfc_manager.dart';
import 'package:nfc_manager_ndef/nfc_manager_ndef.dart';
final Ndef ndef = Ndef.from(tag);
if (ndef == null) {
print('This tag is not compatible with NDEF.');
return;
}
// Do something with an Ndef instance...
print(ndef);
```
The following platform-specific tag classes are available:
#### Android only
* `NfcAAndroid`
* `NfcBAndroid`
* `NfcFAndroid`
* `NfcVAndroid`
* `IsoDepAndroid`
* `MifareClassicAndroid`
* `MifareUltralightAndroid`
* `NfcBarcodeAndroid`
* `NdefAndroid`
* `NdefFormatableAndroid`
#### iOS only
* `FeliCaIos`
* `MiFareIos`
* `Iso15693Ios`
* `Iso7816Ios`
* `NdefIos`
#### Cross-platform abstractions (separate packages)
* `Ndef` ([nfc_manager_ndef](https://pub.dev/packages/nfc_manager_ndef))
* `FeliCa` ([nfc_manager_felica](https://pub.dev/packages/nfc_manager_felica))
* and more...
================================================
FILE: analysis_options.yaml
================================================
include: package:flutter_lints/flutter.yaml
================================================
FILE: android/.gitignore
================================================
*.iml
.gradle
/local.properties
/.idea/workspace.xml
/.idea/libraries
.DS_Store
/build
/captures
.cxx
================================================
FILE: android/build.gradle.kts
================================================
group = "dev.flutter.plugins.nfcmanager"
version = "1.0-SNAPSHOT"
buildscript {
val kotlinVersion = "2.2.20"
repositories {
google()
mavenCentral()
}
dependencies {
classpath("com.android.tools.build:gradle:8.11.1")
classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
}
}
allprojects {
repositories {
google()
mavenCentral()
}
}
plugins {
id("com.android.library")
id("kotlin-android")
}
android {
namespace = "dev.flutter.plugins.nfcmanager"
compileSdk = 36
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
kotlinOptions {
jvmTarget = JavaVersion.VERSION_17.toString()
}
sourceSets {
getByName("main") {
java.srcDirs("src/main/kotlin")
}
getByName("test") {
java.srcDirs("src/test/kotlin")
}
}
defaultConfig {
minSdk = 24
}
testOptions {
unitTests {
isIncludeAndroidResources = true
all {
it.useJUnitPlatform()
it.outputs.upToDateWhen { false }
it.testLogging {
events("passed", "skipped", "failed", "standardOut", "standardError")
showStandardStreams = true
}
}
}
}
}
dependencies {
testImplementation("org.jetbrains.kotlin:kotlin-test")
testImplementation("org.mockito:mockito-core:5.0.0")
}
================================================
FILE: android/settings.gradle
================================================
rootProject.name = 'nfc_manager'
================================================
FILE: android/settings.gradle.kts
================================================
rootProject.name = 'nfc_manager'
================================================
FILE: android/src/main/AndroidManifest.xml
================================================
================================================
FILE: android/src/main/kotlin/dev/flutter/plugins/nfcmanager/NfcManagerPlugin.kt
================================================
package dev.flutter.plugins.nfcmanager
import android.app.Activity
import android.app.PendingIntent
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Context.RECEIVER_NOT_EXPORTED
import android.content.Intent
import android.content.IntentFilter
import android.nfc.NdefMessage
import android.nfc.NdefRecord
import android.nfc.NfcAdapter
import android.nfc.Tag
import android.nfc.tech.IsoDep
import android.nfc.tech.MifareClassic
import android.nfc.tech.MifareUltralight
import android.nfc.tech.Ndef
import android.nfc.tech.NdefFormatable
import android.nfc.tech.NfcA
import android.nfc.tech.NfcB
import android.nfc.tech.NfcBarcode
import android.nfc.tech.NfcF
import android.nfc.tech.NfcV
import android.nfc.tech.TagTechnology
import android.os.Build
import io.flutter.embedding.engine.plugins.FlutterPlugin
import io.flutter.embedding.engine.plugins.activity.ActivityAware
import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding
import java.util.*
class NfcManagerPlugin: FlutterPlugin, ActivityAware, HostApiPigeon, BroadcastReceiver() {
private lateinit var flutterApi: FlutterApiPigeon
private lateinit var activity: Activity
private var adapter: NfcAdapter? = null
private var cachedTags: MutableMap = mutableMapOf()
private var connectedTech: TagTechnology? = null
override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
HostApiPigeon.setUp(flutterPluginBinding.binaryMessenger, this)
flutterApi = FlutterApiPigeon(flutterPluginBinding.binaryMessenger)
adapter = NfcAdapter.getDefaultAdapter(flutterPluginBinding.applicationContext)
}
override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
HostApiPigeon.setUp(binding.binaryMessenger, null)
}
override fun onAttachedToActivity(binding: ActivityPluginBinding) {
activity = binding.activity
val intentFilter = IntentFilter(NfcAdapter.ACTION_ADAPTER_STATE_CHANGED)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
activity.applicationContext.registerReceiver(this, intentFilter, RECEIVER_NOT_EXPORTED)
} else {
activity.applicationContext.registerReceiver(this, intentFilter)
}
}
override fun onReattachedToActivityForConfigChanges(binding: ActivityPluginBinding) {
activity = binding.activity
}
override fun onDetachedFromActivityForConfigChanges() {
// noop
}
override fun onDetachedFromActivity() {
// noop
}
override fun onReceive(context: Context?, intent: Intent?) {
intent ?: run { return }
if (intent.action != NfcAdapter.ACTION_ADAPTER_STATE_CHANGED) { return }
val state = intent.getIntExtra(NfcAdapter.EXTRA_ADAPTER_STATE, NfcAdapter.STATE_OFF)
flutterApi.onAdapterStateChanged(toAdapterStatePigeon(state)) { /* noop */ }
}
override fun nfcAdapterIsEnabled(): Boolean {
return getAdapter().isEnabled
}
override fun nfcAdapterIsSecureNfcEnabled(): Boolean {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
throw FlutterError("unavailable", "Required Android SDK >= ${Build.VERSION_CODES.Q}.", null)
}
return getAdapter().isSecureNfcEnabled
}
override fun nfcAdapterIsSecureNfcSupported(): Boolean {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
throw FlutterError("unavailable", "Required Android SDK >= ${Build.VERSION_CODES.Q}.", null)
}
return getAdapter().isSecureNfcSupported
}
override fun nfcAdapterEnableReaderMode(flags: List) {
getAdapter().enableReaderMode(activity, { onTagDiscovered(it) }, toInt(flags), null)
}
override fun nfcAdapterDisableReaderMode() {
getAdapter().disableReaderMode(activity)
cachedTags.clear() // Consider when to remove the tag.
}
override fun ndefGetNdefMessage(handle: String): NdefMessagePigeon? {
val tech = forceConnect(handle) { Ndef.get(it) }
val message = tech.ndefMessage
return if (message != null) toNdefMessagePigeon(message) else null
}
override fun ndefWriteNdefMessage(handle: String, message: NdefMessagePigeon) {
val tech = forceConnect(handle) { Ndef.get(it) }
tech.writeNdefMessage(toNdefMessage(message))
}
override fun ndefMakeReadOnly(handle: String): Boolean {
val tech = forceConnect(handle) { Ndef.get(it) }
return tech.makeReadOnly()
}
override fun nfcAGetMaxTransceiveLength(handle: String): Long {
val tech = forceConnect(handle) { NfcA.get(it) }
return tech.maxTransceiveLength.toLong()
}
override fun nfcAGetTimeout(handle: String): Long {
val tech = forceConnect(handle) { NfcA.get(it) }
return tech.timeout.toLong()
}
override fun nfcASetTimeout(handle: String, timeout: Long) {
val tech = forceConnect(handle) { NfcA.get(it) }
tech.timeout = timeout.toInt()
}
override fun nfcATransceive(handle: String, bytes: ByteArray): ByteArray {
val tech = forceConnect(handle) { NfcA.get(it) }
return tech.transceive(bytes)
}
override fun nfcBGetMaxTransceiveLength(handle: String): Long {
val tech = forceConnect(handle) { NfcB.get(it) }
return tech.maxTransceiveLength.toLong()
}
override fun nfcBTransceive(handle: String, bytes: ByteArray): ByteArray {
val tech = forceConnect(handle) { NfcB.get(it) }
return tech.transceive(bytes)
}
override fun nfcFGetMaxTransceiveLength(handle: String): Long {
val tech = forceConnect(handle) { NfcF.get(it) }
return tech.maxTransceiveLength.toLong()
}
override fun nfcFGetTimeout(handle: String): Long {
val tech = forceConnect(handle) { NfcF.get(it) }
return tech.timeout.toLong()
}
override fun nfcFSetTimeout(handle: String, timeout: Long) {
val tech = forceConnect(handle) { NfcF.get(it) }
tech.timeout = timeout.toInt()
}
override fun nfcFTransceive(handle: String, bytes: ByteArray): ByteArray {
val tech = forceConnect(handle) { NfcF.get(it) }
return tech.transceive(bytes)
}
override fun nfcVGetMaxTransceiveLength(handle: String): Long {
val tech = forceConnect(handle) { NfcV.get(it) }
return tech.maxTransceiveLength.toLong()
}
override fun nfcVTransceive(handle: String, bytes: ByteArray): ByteArray {
val tech = forceConnect(handle) { NfcV.get(it) }
return tech.transceive(bytes)
}
override fun isoDepGetMaxTransceiveLength(handle: String): Long {
val tech = forceConnect(handle) { IsoDep.get(it) }
return tech.maxTransceiveLength.toLong()
}
override fun isoDepGetTimeout(handle: String): Long {
val tech = forceConnect(handle) { IsoDep.get(it) }
return tech.timeout.toLong()
}
override fun isoDepSetTimeout(handle: String, timeout: Long) {
val tech = forceConnect(handle) { IsoDep.get(it) }
tech.timeout = timeout.toInt()
}
override fun isoDepTransceive(handle: String, bytes: ByteArray): ByteArray {
val tech = forceConnect(handle) { IsoDep.get(it) }
return tech.transceive(bytes)
}
override fun mifareClassicGetMaxTransceiveLength(handle: String): Long {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.maxTransceiveLength.toLong()
}
override fun mifareClassicGetTimeout(handle: String): Long {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.timeout.toLong()
}
override fun mifareClassicSetTimeout(handle: String, timeout: Long) {
val tech = forceConnect(handle) { MifareClassic.get(it) }
tech.timeout = timeout.toInt()
}
override fun mifareClassicAuthenticateSectorWithKeyA(handle: String, sectorIndex: Long, key: ByteArray): Boolean {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.authenticateSectorWithKeyA(sectorIndex.toInt(), key)
}
override fun mifareClassicAuthenticateSectorWithKeyB(handle: String, sectorIndex: Long, key: ByteArray): Boolean {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.authenticateSectorWithKeyB(sectorIndex.toInt(), key)
}
override fun mifareClassicGetBlockCountInSector(handle: String, sectorIndex: Long): Long {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.getBlockCountInSector(sectorIndex.toInt()).toLong()
}
override fun mifareClassicBlockToSector(handle: String, blockIndex: Long): Long {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.blockToSector(blockIndex.toInt()).toLong()
}
override fun mifareClassicSectorToBlock(handle: String, sectorIndex: Long): Long {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.sectorToBlock(sectorIndex.toInt()).toLong()
}
override fun mifareClassicIncrement(handle: String, blockIndex: Long, value: Long) {
val tech = forceConnect(handle) { MifareClassic.get(it) }
tech.increment(blockIndex.toInt(), value.toInt())
}
override fun mifareClassicDecrement(handle: String, blockIndex: Long, value: Long) {
val tech = forceConnect(handle) { MifareClassic.get(it) }
tech.decrement(blockIndex.toInt(), value.toInt())
}
override fun mifareClassicRestore(handle: String, blockIndex: Long) {
val tech = forceConnect(handle) { MifareClassic.get(it) }
tech.restore(blockIndex.toInt())
}
override fun mifareClassicTransfer(handle: String, blockIndex: Long) {
val tech = forceConnect(handle) { MifareClassic.get(it) }
tech.transfer(blockIndex.toInt())
}
override fun mifareClassicReadBlock(handle: String, blockIndex: Long): ByteArray {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.readBlock(blockIndex.toInt())
}
override fun mifareClassicWriteBlock(handle: String, blockIndex: Long, data: ByteArray) {
val tech = forceConnect(handle) { MifareClassic.get(it) }
tech.writeBlock(blockIndex.toInt(), data)
}
override fun mifareClassicTransceive(handle: String, bytes: ByteArray): ByteArray {
val tech = forceConnect(handle) { MifareClassic.get(it) }
return tech.transceive(bytes)
}
override fun mifareUltralightGetMaxTransceiveLength(handle: String): Long {
val tech = forceConnect(handle) { MifareUltralight.get(it) }
return tech.maxTransceiveLength.toLong()
}
override fun mifareUltralightGetTimeout(handle: String): Long {
val tech = forceConnect(handle) { MifareUltralight.get(it) }
return tech.timeout.toLong()
}
override fun mifareUltralightSetTimeout(handle: String, timeout: Long) {
val tech = forceConnect(handle) { MifareUltralight.get(it) }
tech.timeout = timeout.toInt()
}
override fun mifareUltralightReadPages(handle: String, pageOffset: Long): ByteArray {
val tech = forceConnect(handle) { MifareUltralight.get(it) }
return tech.readPages(pageOffset.toInt())
}
override fun mifareUltralightWritePage(handle: String, pageOffset: Long, data: ByteArray) {
val tech = forceConnect(handle) { MifareUltralight.get(it) }
tech.writePage(pageOffset.toInt(), data)
}
override fun mifareUltralightTransceive(handle: String, bytes: ByteArray): ByteArray {
val tech = forceConnect(handle) { MifareUltralight.get(it) }
return tech.transceive(bytes)
}
override fun ndefFormatableFormat(handle: String, firstMessage: NdefMessagePigeon) {
val tech = forceConnect(handle) { NdefFormatable.get(it) }
tech.format(toNdefMessage(firstMessage))
}
override fun ndefFormatableFormatReadOnly(handle: String, firstMessage: NdefMessagePigeon) {
val tech = forceConnect(handle) { NdefFormatable.get(it) }
tech.formatReadOnly(toNdefMessage(firstMessage))
}
private fun onTagDiscovered(tag: Tag) {
val handle = UUID.randomUUID().toString()
val pigeonTag = toTagPigeon(tag, handle)
cachedTags[handle] = tag
activity.runOnUiThread { flutterApi.onTagDiscovered(pigeonTag) { /* no op */ } }
}
private fun getAdapter(): NfcAdapter {
return adapter ?: run { throw FlutterError("not_supported", "NFC is not supported on this device.", null) }
}
private inline fun forceConnect(handle: String, getMethod: (Tag) -> T?): T {
val tag = cachedTags[handle] ?: run {
throw FlutterError("tag_not_found", "You may have disable the session.", null)
}
val tech = getMethod(tag) ?: run {
throw FlutterError("tag_not_found", "The tag cannot be converted to ${T::class.java.name}.", null)
}
val connectedTech = connectedTech ?: run {
tech.connect()
connectedTech = tech
return tech
}
if (connectedTech.tag != tech.tag || connectedTech::class.java.name != tech::class.java.name) {
try {
connectedTech.close()
} catch (e: Exception) {
/* no op */
}
tech.connect()
this.connectedTech = tech
}
return tech
}
}
private fun toInt(value: List): Int {
return value.fold(0) { p, e -> p or toInt(e)}
}
private fun toInt(value: ReaderFlagPigeon): Int {
return when (value) {
ReaderFlagPigeon.NFC_A-> NfcAdapter.FLAG_READER_NFC_A
ReaderFlagPigeon.NFC_B -> NfcAdapter.FLAG_READER_NFC_B
ReaderFlagPigeon.NFC_BARCODE -> NfcAdapter.FLAG_READER_NFC_BARCODE
ReaderFlagPigeon.NFC_F -> NfcAdapter.FLAG_READER_NFC_F
ReaderFlagPigeon.NFC_V -> NfcAdapter.FLAG_READER_NFC_V
ReaderFlagPigeon.NO_PLATFORM_SOUNDS -> NfcAdapter.FLAG_READER_NO_PLATFORM_SOUNDS
ReaderFlagPigeon.SKIP_NDEF_CHECK -> NfcAdapter.FLAG_READER_SKIP_NDEF_CHECK
}
}
private fun toNdefMessage(value: NdefMessagePigeon): NdefMessage {
return NdefMessage(value.records.map { toNdefRecord(it) }.toTypedArray())
}
private fun toNdefMessagePigeon(value: NdefMessage): NdefMessagePigeon {
return NdefMessagePigeon(
records = value.records.map { toNdefRecordPigeon(it) }
)
}
private fun toNdefRecord(value: NdefRecordPigeon): NdefRecord {
return NdefRecord(
toShort(value.tnf),
value.type,
value.id,
value.payload,
)
}
private fun toNdefRecordPigeon(value: NdefRecord): NdefRecordPigeon {
return NdefRecordPigeon(
tnf = toTypeNameFormatPigeon(value.tnf),
type = value.type,
id = value.id,
payload = value.payload,
)
}
private fun toTagPigeon(value: Tag, handle: String): TagPigeon {
return TagPigeon(
handle = handle,
id = value.id,
techList = value.techList.toMutableList(),
ndef = Ndef.get(value)?.let { toNdefPigeon(it) },
nfcA = NfcA.get(value)?.let { toNfcAPigeon(it) },
nfcB = NfcB.get(value)?.let { toNfcBPigeon(it) },
nfcF = NfcF.get(value)?.let { toNfcFPigeon(it) },
nfcV = NfcV.get(value)?.let { toNfcVPigeon(it) },
isoDep = IsoDep.get(value)?.let { toIsoDepPigeon(it) },
mifareClassic = MifareClassic.get(value)?.let { toMifareClassicPigeon(it) },
mifareUltralight = MifareUltralight.get(value)?.let { toMifareUltralightPigeon(it) },
ndefFormatable = NdefFormatable.get(value)?.let { "" },
nfcBarcode = NfcBarcode.get(value)?.let { toNfcBarcodePigeon(it) },
)
}
private fun toNdefPigeon(value: Ndef): NdefPigeon {
return NdefPigeon(
type = value.type,
isWritable = value.isWritable,
maxSize = value.maxSize.toLong(),
canMakeReadOnly = value.canMakeReadOnly(),
cachedNdefMessage = value.cachedNdefMessage?.let { toNdefMessagePigeon(it) },
)
}
private fun toNfcAPigeon(value: NfcA): NfcAPigeon {
return NfcAPigeon(
atqa = value.atqa,
sak = value.sak.toLong(),
)
}
private fun toNfcBPigeon(value: NfcB): NfcBPigeon {
return NfcBPigeon(
applicationData = value.applicationData,
protocolInfo = value.protocolInfo,
)
}
private fun toNfcFPigeon(value: NfcF): NfcFPigeon {
return NfcFPigeon(
manufacturer = value.manufacturer,
systemCode = value.systemCode,
)
}
private fun toNfcVPigeon(value: NfcV): NfcVPigeon {
return NfcVPigeon(
dsfId = value.dsfId.toLong(),
responseFlags = value.responseFlags.toLong(),
)
}
private fun toIsoDepPigeon(value: IsoDep): IsoDepPigeon {
return IsoDepPigeon(
hiLayerResponse = value.hiLayerResponse,
historicalBytes = value.historicalBytes,
isExtendedLengthApduSupported = value.isExtendedLengthApduSupported,
)
}
private fun toMifareClassicPigeon(value: MifareClassic): MifareClassicPigeon {
return MifareClassicPigeon(
type = toMifareClassicTypePigeon(value.type),
blockCount = value.blockCount.toLong(),
sectorCount = value.sectorCount.toLong(),
size = value.size.toLong(),
)
}
private fun toMifareUltralightPigeon(value: MifareUltralight): MifareUltralightPigeon {
return MifareUltralightPigeon(
type = toMifareUltralightTypePigeon(value.type)
)
}
private fun toNfcBarcodePigeon(value: NfcBarcode): NfcBarcodePigeon {
return NfcBarcodePigeon(
type = toNfcBarcodeTypePigeon(value.type),
barcode = value.barcode,
)
}
private fun toShort(value: TypeNameFormatPigeon): Short {
return when (value) {
TypeNameFormatPigeon.EMPTY -> NdefRecord.TNF_EMPTY
TypeNameFormatPigeon.WELL_KNOWN -> NdefRecord.TNF_WELL_KNOWN
TypeNameFormatPigeon.MEDIA -> NdefRecord.TNF_MIME_MEDIA
TypeNameFormatPigeon.ABSOLUTE_URI -> NdefRecord.TNF_ABSOLUTE_URI
TypeNameFormatPigeon.EXTERNAL -> NdefRecord.TNF_EXTERNAL_TYPE
TypeNameFormatPigeon.UNKNOWN -> NdefRecord.TNF_UNKNOWN
TypeNameFormatPigeon.UNCHANGED -> NdefRecord.TNF_UNCHANGED
}
}
private fun toAdapterStatePigeon(value: Int): AdapterStatePigeon {
return when (value) {
NfcAdapter.STATE_OFF -> AdapterStatePigeon.OFF
NfcAdapter.STATE_TURNING_ON -> AdapterStatePigeon.TURNING_ON
NfcAdapter.STATE_ON -> AdapterStatePigeon.ON
NfcAdapter.STATE_TURNING_OFF -> AdapterStatePigeon.TURNING_OFF
else -> error("Unknown value: $value")
}
}
private fun toTypeNameFormatPigeon(value: Short): TypeNameFormatPigeon {
return when (value) {
NdefRecord.TNF_EMPTY -> TypeNameFormatPigeon.EMPTY
NdefRecord.TNF_WELL_KNOWN -> TypeNameFormatPigeon.WELL_KNOWN
NdefRecord.TNF_MIME_MEDIA -> TypeNameFormatPigeon.MEDIA
NdefRecord.TNF_ABSOLUTE_URI -> TypeNameFormatPigeon.ABSOLUTE_URI
NdefRecord.TNF_EXTERNAL_TYPE -> TypeNameFormatPigeon.EXTERNAL
NdefRecord.TNF_UNKNOWN -> TypeNameFormatPigeon.UNKNOWN
NdefRecord.TNF_UNCHANGED -> TypeNameFormatPigeon.UNCHANGED
else -> error("Unknown value: $value")
}
}
private fun toNfcBarcodeTypePigeon(value: Int): NfcBarcodeTypePigeon {
return when (value) {
NfcBarcode.TYPE_KOVIO -> NfcBarcodeTypePigeon.KOVIO
NfcBarcode.TYPE_UNKNOWN -> NfcBarcodeTypePigeon.UNKNOWN
else -> error("Unknown value: $value")
}
}
private fun toMifareClassicTypePigeon(value: Int): MifareClassicTypePigeon {
return when (value) {
MifareClassic.TYPE_CLASSIC -> MifareClassicTypePigeon.CLASSIC
MifareClassic.TYPE_PLUS -> MifareClassicTypePigeon.PLUS
MifareClassic.TYPE_PRO -> MifareClassicTypePigeon.PRO
MifareClassic.TYPE_UNKNOWN -> MifareClassicTypePigeon.UNKNOWN
else -> error("Unknown value: $value")
}
}
private fun toMifareUltralightTypePigeon(value: Int): MifareUltralightTypePigeon {
return when (value) {
MifareUltralight.TYPE_ULTRALIGHT -> MifareUltralightTypePigeon.ULTRALIGHT
MifareUltralight.TYPE_ULTRALIGHT_C -> MifareUltralightTypePigeon.ULTRALIGHT_C
MifareUltralight.TYPE_UNKNOWN -> MifareUltralightTypePigeon.UNKNOWN
else -> error("Unknown value: $value")
}
}
================================================
FILE: android/src/main/kotlin/dev/flutter/plugins/nfcmanager/Pigeon.kt
================================================
// Autogenerated from Pigeon (v26.3.3), do not edit directly.
// See also: https://pub.dev/packages/pigeon
@file:Suppress("UNCHECKED_CAST", "ArrayInDataClass")
package dev.flutter.plugins.nfcmanager
import android.util.Log
import io.flutter.plugin.common.BasicMessageChannel
import io.flutter.plugin.common.BinaryMessenger
import io.flutter.plugin.common.EventChannel
import io.flutter.plugin.common.MessageCodec
import io.flutter.plugin.common.StandardMethodCodec
import io.flutter.plugin.common.StandardMessageCodec
import java.io.ByteArrayOutputStream
import java.nio.ByteBuffer
private object PigeonPigeonUtils {
fun createConnectionError(channelName: String): FlutterError {
return FlutterError("channel-error", "Unable to establish connection on channel: '$channelName'.", "") }
fun wrapResult(result: Any?): List {
return listOf(result)
}
fun wrapError(exception: Throwable): List {
return if (exception is FlutterError) {
listOf(
exception.code,
exception.message,
exception.details
)
} else {
listOf(
exception.javaClass.simpleName,
exception.toString(),
"Cause: " + exception.cause + ", Stacktrace: " + Log.getStackTraceString(exception)
)
}
}
fun doubleEquals(a: Double, b: Double): Boolean {
// Normalize -0.0 to 0.0 and handle NaN equality.
return (if (a == 0.0) 0.0 else a) == (if (b == 0.0) 0.0 else b) || (a.isNaN() && b.isNaN())
}
fun floatEquals(a: Float, b: Float): Boolean {
// Normalize -0.0 to 0.0 and handle NaN equality.
return (if (a == 0.0f) 0.0f else a) == (if (b == 0.0f) 0.0f else b) || (a.isNaN() && b.isNaN())
}
fun doubleHash(d: Double): Int {
// Normalize -0.0 to 0.0 and handle NaN to ensure consistent hash codes.
val normalized = if (d == 0.0) 0.0 else d
val bits = java.lang.Double.doubleToLongBits(normalized)
return (bits xor (bits ushr 32)).toInt()
}
fun floatHash(f: Float): Int {
// Normalize -0.0 to 0.0 and handle NaN to ensure consistent hash codes.
val normalized = if (f == 0.0f) 0.0f else f
return java.lang.Float.floatToIntBits(normalized)
}
fun deepEquals(a: Any?, b: Any?): Boolean {
if (a === b) {
return true
}
if (a == null || b == null) {
return false
}
if (a is ByteArray && b is ByteArray) {
return a.contentEquals(b)
}
if (a is IntArray && b is IntArray) {
return a.contentEquals(b)
}
if (a is LongArray && b is LongArray) {
return a.contentEquals(b)
}
if (a is DoubleArray && b is DoubleArray) {
if (a.size != b.size) return false
for (i in a.indices) {
if (!doubleEquals(a[i], b[i])) return false
}
return true
}
if (a is FloatArray && b is FloatArray) {
if (a.size != b.size) return false
for (i in a.indices) {
if (!floatEquals(a[i], b[i])) return false
}
return true
}
if (a is Array<*> && b is Array<*>) {
if (a.size != b.size) return false
for (i in a.indices) {
if (!deepEquals(a[i], b[i])) return false
}
return true
}
if (a is List<*> && b is List<*>) {
if (a.size != b.size) return false
val iterA = a.iterator()
val iterB = b.iterator()
while (iterA.hasNext() && iterB.hasNext()) {
if (!deepEquals(iterA.next(), iterB.next())) return false
}
return true
}
if (a is Map<*, *> && b is Map<*, *>) {
if (a.size != b.size) return false
for (entry in a) {
val key = entry.key
var found = false
for (bEntry in b) {
if (deepEquals(key, bEntry.key)) {
if (deepEquals(entry.value, bEntry.value)) {
found = true
break
} else {
return false
}
}
}
if (!found) return false
}
return true
}
if (a is Double && b is Double) {
return doubleEquals(a, b)
}
if (a is Float && b is Float) {
return floatEquals(a, b)
}
return a == b
}
fun deepHash(value: Any?): Int {
return when (value) {
null -> 0
is ByteArray -> value.contentHashCode()
is IntArray -> value.contentHashCode()
is LongArray -> value.contentHashCode()
is DoubleArray -> {
var result = 1
for (item in value) {
result = 31 * result + doubleHash(item)
}
result
}
is FloatArray -> {
var result = 1
for (item in value) {
result = 31 * result + floatHash(item)
}
result
}
is Array<*> -> {
var result = 1
for (item in value) {
result = 31 * result + deepHash(item)
}
result
}
is List<*> -> {
var result = 1
for (item in value) {
result = 31 * result + deepHash(item)
}
result
}
is Map<*, *> -> {
var result = 0
for (entry in value) {
result += ((deepHash(entry.key) * 31) xor deepHash(entry.value))
}
result
}
is Double -> doubleHash(value)
is Float -> floatHash(value)
else -> value.hashCode()
}
}
}
/**
* Error class for passing custom error details to Flutter via a thrown PlatformException.
* @property code The error code.
* @property message The error message.
* @property details The error details. Must be a datatype supported by the api codec.
*/
class FlutterError (
val code: String,
override val message: String? = null,
val details: Any? = null
) : Throwable()
enum class ReaderFlagPigeon(val raw: Int) {
NFC_A(0),
NFC_B(1),
NFC_BARCODE(2),
NFC_F(3),
NFC_V(4),
NO_PLATFORM_SOUNDS(5),
SKIP_NDEF_CHECK(6);
companion object {
fun ofRaw(raw: Int): ReaderFlagPigeon? {
return values().firstOrNull { it.raw == raw }
}
}
}
enum class AdapterStatePigeon(val raw: Int) {
OFF(0),
TURNING_ON(1),
ON(2),
TURNING_OFF(3);
companion object {
fun ofRaw(raw: Int): AdapterStatePigeon? {
return values().firstOrNull { it.raw == raw }
}
}
}
enum class TypeNameFormatPigeon(val raw: Int) {
EMPTY(0),
WELL_KNOWN(1),
MEDIA(2),
ABSOLUTE_URI(3),
EXTERNAL(4),
UNKNOWN(5),
UNCHANGED(6);
companion object {
fun ofRaw(raw: Int): TypeNameFormatPigeon? {
return values().firstOrNull { it.raw == raw }
}
}
}
enum class NfcBarcodeTypePigeon(val raw: Int) {
KOVIO(0),
UNKNOWN(1);
companion object {
fun ofRaw(raw: Int): NfcBarcodeTypePigeon? {
return values().firstOrNull { it.raw == raw }
}
}
}
enum class MifareClassicTypePigeon(val raw: Int) {
CLASSIC(0),
PLUS(1),
PRO(2),
UNKNOWN(3);
companion object {
fun ofRaw(raw: Int): MifareClassicTypePigeon? {
return values().firstOrNull { it.raw == raw }
}
}
}
enum class MifareUltralightTypePigeon(val raw: Int) {
ULTRALIGHT(0),
ULTRALIGHT_C(1),
UNKNOWN(2);
companion object {
fun ofRaw(raw: Int): MifareUltralightTypePigeon? {
return values().firstOrNull { it.raw == raw }
}
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class TagPigeon (
val handle: String,
val id: ByteArray,
val techList: List,
val ndef: NdefPigeon? = null,
val nfcA: NfcAPigeon? = null,
val nfcB: NfcBPigeon? = null,
val nfcF: NfcFPigeon? = null,
val nfcV: NfcVPigeon? = null,
val isoDep: IsoDepPigeon? = null,
val mifareClassic: MifareClassicPigeon? = null,
val mifareUltralight: MifareUltralightPigeon? = null,
val ndefFormatable: String? = null,
val nfcBarcode: NfcBarcodePigeon? = null
)
{
companion object {
fun fromList(pigeonVar_list: List): TagPigeon {
val handle = pigeonVar_list[0] as String
val id = pigeonVar_list[1] as ByteArray
val techList = pigeonVar_list[2] as List
val ndef = pigeonVar_list[3] as NdefPigeon?
val nfcA = pigeonVar_list[4] as NfcAPigeon?
val nfcB = pigeonVar_list[5] as NfcBPigeon?
val nfcF = pigeonVar_list[6] as NfcFPigeon?
val nfcV = pigeonVar_list[7] as NfcVPigeon?
val isoDep = pigeonVar_list[8] as IsoDepPigeon?
val mifareClassic = pigeonVar_list[9] as MifareClassicPigeon?
val mifareUltralight = pigeonVar_list[10] as MifareUltralightPigeon?
val ndefFormatable = pigeonVar_list[11] as String?
val nfcBarcode = pigeonVar_list[12] as NfcBarcodePigeon?
return TagPigeon(handle, id, techList, ndef, nfcA, nfcB, nfcF, nfcV, isoDep, mifareClassic, mifareUltralight, ndefFormatable, nfcBarcode)
}
}
fun toList(): List {
return listOf(
handle,
id,
techList,
ndef,
nfcA,
nfcB,
nfcF,
nfcV,
isoDep,
mifareClassic,
mifareUltralight,
ndefFormatable,
nfcBarcode,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as TagPigeon
return PigeonPigeonUtils.deepEquals(this.handle, other.handle) && PigeonPigeonUtils.deepEquals(this.id, other.id) && PigeonPigeonUtils.deepEquals(this.techList, other.techList) && PigeonPigeonUtils.deepEquals(this.ndef, other.ndef) && PigeonPigeonUtils.deepEquals(this.nfcA, other.nfcA) && PigeonPigeonUtils.deepEquals(this.nfcB, other.nfcB) && PigeonPigeonUtils.deepEquals(this.nfcF, other.nfcF) && PigeonPigeonUtils.deepEquals(this.nfcV, other.nfcV) && PigeonPigeonUtils.deepEquals(this.isoDep, other.isoDep) && PigeonPigeonUtils.deepEquals(this.mifareClassic, other.mifareClassic) && PigeonPigeonUtils.deepEquals(this.mifareUltralight, other.mifareUltralight) && PigeonPigeonUtils.deepEquals(this.ndefFormatable, other.ndefFormatable) && PigeonPigeonUtils.deepEquals(this.nfcBarcode, other.nfcBarcode)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.handle)
result = 31 * result + PigeonPigeonUtils.deepHash(this.id)
result = 31 * result + PigeonPigeonUtils.deepHash(this.techList)
result = 31 * result + PigeonPigeonUtils.deepHash(this.ndef)
result = 31 * result + PigeonPigeonUtils.deepHash(this.nfcA)
result = 31 * result + PigeonPigeonUtils.deepHash(this.nfcB)
result = 31 * result + PigeonPigeonUtils.deepHash(this.nfcF)
result = 31 * result + PigeonPigeonUtils.deepHash(this.nfcV)
result = 31 * result + PigeonPigeonUtils.deepHash(this.isoDep)
result = 31 * result + PigeonPigeonUtils.deepHash(this.mifareClassic)
result = 31 * result + PigeonPigeonUtils.deepHash(this.mifareUltralight)
result = 31 * result + PigeonPigeonUtils.deepHash(this.ndefFormatable)
result = 31 * result + PigeonPigeonUtils.deepHash(this.nfcBarcode)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class NdefPigeon (
val type: String,
val canMakeReadOnly: Boolean,
val isWritable: Boolean,
val maxSize: Long,
val cachedNdefMessage: NdefMessagePigeon? = null
)
{
companion object {
fun fromList(pigeonVar_list: List): NdefPigeon {
val type = pigeonVar_list[0] as String
val canMakeReadOnly = pigeonVar_list[1] as Boolean
val isWritable = pigeonVar_list[2] as Boolean
val maxSize = pigeonVar_list[3] as Long
val cachedNdefMessage = pigeonVar_list[4] as NdefMessagePigeon?
return NdefPigeon(type, canMakeReadOnly, isWritable, maxSize, cachedNdefMessage)
}
}
fun toList(): List {
return listOf(
type,
canMakeReadOnly,
isWritable,
maxSize,
cachedNdefMessage,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as NdefPigeon
return PigeonPigeonUtils.deepEquals(this.type, other.type) && PigeonPigeonUtils.deepEquals(this.canMakeReadOnly, other.canMakeReadOnly) && PigeonPigeonUtils.deepEquals(this.isWritable, other.isWritable) && PigeonPigeonUtils.deepEquals(this.maxSize, other.maxSize) && PigeonPigeonUtils.deepEquals(this.cachedNdefMessage, other.cachedNdefMessage)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.type)
result = 31 * result + PigeonPigeonUtils.deepHash(this.canMakeReadOnly)
result = 31 * result + PigeonPigeonUtils.deepHash(this.isWritable)
result = 31 * result + PigeonPigeonUtils.deepHash(this.maxSize)
result = 31 * result + PigeonPigeonUtils.deepHash(this.cachedNdefMessage)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class NfcAPigeon (
val atqa: ByteArray,
val sak: Long
)
{
companion object {
fun fromList(pigeonVar_list: List): NfcAPigeon {
val atqa = pigeonVar_list[0] as ByteArray
val sak = pigeonVar_list[1] as Long
return NfcAPigeon(atqa, sak)
}
}
fun toList(): List {
return listOf(
atqa,
sak,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as NfcAPigeon
return PigeonPigeonUtils.deepEquals(this.atqa, other.atqa) && PigeonPigeonUtils.deepEquals(this.sak, other.sak)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.atqa)
result = 31 * result + PigeonPigeonUtils.deepHash(this.sak)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class NfcBPigeon (
val applicationData: ByteArray,
val protocolInfo: ByteArray
)
{
companion object {
fun fromList(pigeonVar_list: List): NfcBPigeon {
val applicationData = pigeonVar_list[0] as ByteArray
val protocolInfo = pigeonVar_list[1] as ByteArray
return NfcBPigeon(applicationData, protocolInfo)
}
}
fun toList(): List {
return listOf(
applicationData,
protocolInfo,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as NfcBPigeon
return PigeonPigeonUtils.deepEquals(this.applicationData, other.applicationData) && PigeonPigeonUtils.deepEquals(this.protocolInfo, other.protocolInfo)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.applicationData)
result = 31 * result + PigeonPigeonUtils.deepHash(this.protocolInfo)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class NfcFPigeon (
val manufacturer: ByteArray,
val systemCode: ByteArray
)
{
companion object {
fun fromList(pigeonVar_list: List): NfcFPigeon {
val manufacturer = pigeonVar_list[0] as ByteArray
val systemCode = pigeonVar_list[1] as ByteArray
return NfcFPigeon(manufacturer, systemCode)
}
}
fun toList(): List {
return listOf(
manufacturer,
systemCode,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as NfcFPigeon
return PigeonPigeonUtils.deepEquals(this.manufacturer, other.manufacturer) && PigeonPigeonUtils.deepEquals(this.systemCode, other.systemCode)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.manufacturer)
result = 31 * result + PigeonPigeonUtils.deepHash(this.systemCode)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class NfcVPigeon (
val dsfId: Long,
val responseFlags: Long
)
{
companion object {
fun fromList(pigeonVar_list: List): NfcVPigeon {
val dsfId = pigeonVar_list[0] as Long
val responseFlags = pigeonVar_list[1] as Long
return NfcVPigeon(dsfId, responseFlags)
}
}
fun toList(): List {
return listOf(
dsfId,
responseFlags,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as NfcVPigeon
return PigeonPigeonUtils.deepEquals(this.dsfId, other.dsfId) && PigeonPigeonUtils.deepEquals(this.responseFlags, other.responseFlags)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.dsfId)
result = 31 * result + PigeonPigeonUtils.deepHash(this.responseFlags)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class IsoDepPigeon (
val hiLayerResponse: ByteArray? = null,
val historicalBytes: ByteArray? = null,
val isExtendedLengthApduSupported: Boolean
)
{
companion object {
fun fromList(pigeonVar_list: List): IsoDepPigeon {
val hiLayerResponse = pigeonVar_list[0] as ByteArray?
val historicalBytes = pigeonVar_list[1] as ByteArray?
val isExtendedLengthApduSupported = pigeonVar_list[2] as Boolean
return IsoDepPigeon(hiLayerResponse, historicalBytes, isExtendedLengthApduSupported)
}
}
fun toList(): List {
return listOf(
hiLayerResponse,
historicalBytes,
isExtendedLengthApduSupported,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as IsoDepPigeon
return PigeonPigeonUtils.deepEquals(this.hiLayerResponse, other.hiLayerResponse) && PigeonPigeonUtils.deepEquals(this.historicalBytes, other.historicalBytes) && PigeonPigeonUtils.deepEquals(this.isExtendedLengthApduSupported, other.isExtendedLengthApduSupported)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.hiLayerResponse)
result = 31 * result + PigeonPigeonUtils.deepHash(this.historicalBytes)
result = 31 * result + PigeonPigeonUtils.deepHash(this.isExtendedLengthApduSupported)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class MifareClassicPigeon (
val type: MifareClassicTypePigeon,
val blockCount: Long,
val sectorCount: Long,
val size: Long
)
{
companion object {
fun fromList(pigeonVar_list: List): MifareClassicPigeon {
val type = pigeonVar_list[0] as MifareClassicTypePigeon
val blockCount = pigeonVar_list[1] as Long
val sectorCount = pigeonVar_list[2] as Long
val size = pigeonVar_list[3] as Long
return MifareClassicPigeon(type, blockCount, sectorCount, size)
}
}
fun toList(): List {
return listOf(
type,
blockCount,
sectorCount,
size,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as MifareClassicPigeon
return PigeonPigeonUtils.deepEquals(this.type, other.type) && PigeonPigeonUtils.deepEquals(this.blockCount, other.blockCount) && PigeonPigeonUtils.deepEquals(this.sectorCount, other.sectorCount) && PigeonPigeonUtils.deepEquals(this.size, other.size)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.type)
result = 31 * result + PigeonPigeonUtils.deepHash(this.blockCount)
result = 31 * result + PigeonPigeonUtils.deepHash(this.sectorCount)
result = 31 * result + PigeonPigeonUtils.deepHash(this.size)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class MifareUltralightPigeon (
val type: MifareUltralightTypePigeon
)
{
companion object {
fun fromList(pigeonVar_list: List): MifareUltralightPigeon {
val type = pigeonVar_list[0] as MifareUltralightTypePigeon
return MifareUltralightPigeon(type)
}
}
fun toList(): List {
return listOf(
type,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as MifareUltralightPigeon
return PigeonPigeonUtils.deepEquals(this.type, other.type)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.type)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class NfcBarcodePigeon (
val type: NfcBarcodeTypePigeon,
val barcode: ByteArray
)
{
companion object {
fun fromList(pigeonVar_list: List): NfcBarcodePigeon {
val type = pigeonVar_list[0] as NfcBarcodeTypePigeon
val barcode = pigeonVar_list[1] as ByteArray
return NfcBarcodePigeon(type, barcode)
}
}
fun toList(): List {
return listOf(
type,
barcode,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as NfcBarcodePigeon
return PigeonPigeonUtils.deepEquals(this.type, other.type) && PigeonPigeonUtils.deepEquals(this.barcode, other.barcode)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.type)
result = 31 * result + PigeonPigeonUtils.deepHash(this.barcode)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class NdefMessagePigeon (
val records: List
)
{
companion object {
fun fromList(pigeonVar_list: List): NdefMessagePigeon {
val records = pigeonVar_list[0] as List
return NdefMessagePigeon(records)
}
}
fun toList(): List {
return listOf(
records,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as NdefMessagePigeon
return PigeonPigeonUtils.deepEquals(this.records, other.records)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.records)
return result
}
}
/** Generated class from Pigeon that represents data sent in messages. */
data class NdefRecordPigeon (
val tnf: TypeNameFormatPigeon,
val type: ByteArray,
val id: ByteArray,
val payload: ByteArray
)
{
companion object {
fun fromList(pigeonVar_list: List): NdefRecordPigeon {
val tnf = pigeonVar_list[0] as TypeNameFormatPigeon
val type = pigeonVar_list[1] as ByteArray
val id = pigeonVar_list[2] as ByteArray
val payload = pigeonVar_list[3] as ByteArray
return NdefRecordPigeon(tnf, type, id, payload)
}
}
fun toList(): List {
return listOf(
tnf,
type,
id,
payload,
)
}
override fun equals(other: Any?): Boolean {
if (other == null || other.javaClass != javaClass) {
return false
}
if (this === other) {
return true
}
val other = other as NdefRecordPigeon
return PigeonPigeonUtils.deepEquals(this.tnf, other.tnf) && PigeonPigeonUtils.deepEquals(this.type, other.type) && PigeonPigeonUtils.deepEquals(this.id, other.id) && PigeonPigeonUtils.deepEquals(this.payload, other.payload)
}
override fun hashCode(): Int {
var result = javaClass.hashCode()
result = 31 * result + PigeonPigeonUtils.deepHash(this.tnf)
result = 31 * result + PigeonPigeonUtils.deepHash(this.type)
result = 31 * result + PigeonPigeonUtils.deepHash(this.id)
result = 31 * result + PigeonPigeonUtils.deepHash(this.payload)
return result
}
}
private open class PigeonPigeonCodec : StandardMessageCodec() {
override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
return when (type) {
129.toByte() -> {
return (readValue(buffer) as Long?)?.let {
ReaderFlagPigeon.ofRaw(it.toInt())
}
}
130.toByte() -> {
return (readValue(buffer) as Long?)?.let {
AdapterStatePigeon.ofRaw(it.toInt())
}
}
131.toByte() -> {
return (readValue(buffer) as Long?)?.let {
TypeNameFormatPigeon.ofRaw(it.toInt())
}
}
132.toByte() -> {
return (readValue(buffer) as Long?)?.let {
NfcBarcodeTypePigeon.ofRaw(it.toInt())
}
}
133.toByte() -> {
return (readValue(buffer) as Long?)?.let {
MifareClassicTypePigeon.ofRaw(it.toInt())
}
}
134.toByte() -> {
return (readValue(buffer) as Long?)?.let {
MifareUltralightTypePigeon.ofRaw(it.toInt())
}
}
135.toByte() -> {
return (readValue(buffer) as? List)?.let {
TagPigeon.fromList(it)
}
}
136.toByte() -> {
return (readValue(buffer) as? List)?.let {
NdefPigeon.fromList(it)
}
}
137.toByte() -> {
return (readValue(buffer) as? List)?.let {
NfcAPigeon.fromList(it)
}
}
138.toByte() -> {
return (readValue(buffer) as? List)?.let {
NfcBPigeon.fromList(it)
}
}
139.toByte() -> {
return (readValue(buffer) as? List)?.let {
NfcFPigeon.fromList(it)
}
}
140.toByte() -> {
return (readValue(buffer) as? List)?.let {
NfcVPigeon.fromList(it)
}
}
141.toByte() -> {
return (readValue(buffer) as? List)?.let {
IsoDepPigeon.fromList(it)
}
}
142.toByte() -> {
return (readValue(buffer) as? List)?.let {
MifareClassicPigeon.fromList(it)
}
}
143.toByte() -> {
return (readValue(buffer) as? List)?.let {
MifareUltralightPigeon.fromList(it)
}
}
144.toByte() -> {
return (readValue(buffer) as? List)?.let {
NfcBarcodePigeon.fromList(it)
}
}
145.toByte() -> {
return (readValue(buffer) as? List)?.let {
NdefMessagePigeon.fromList(it)
}
}
146.toByte() -> {
return (readValue(buffer) as? List)?.let {
NdefRecordPigeon.fromList(it)
}
}
else -> super.readValueOfType(type, buffer)
}
}
override fun writeValue(stream: ByteArrayOutputStream, value: Any?) {
when (value) {
is ReaderFlagPigeon -> {
stream.write(129)
writeValue(stream, value.raw.toLong())
}
is AdapterStatePigeon -> {
stream.write(130)
writeValue(stream, value.raw.toLong())
}
is TypeNameFormatPigeon -> {
stream.write(131)
writeValue(stream, value.raw.toLong())
}
is NfcBarcodeTypePigeon -> {
stream.write(132)
writeValue(stream, value.raw.toLong())
}
is MifareClassicTypePigeon -> {
stream.write(133)
writeValue(stream, value.raw.toLong())
}
is MifareUltralightTypePigeon -> {
stream.write(134)
writeValue(stream, value.raw.toLong())
}
is TagPigeon -> {
stream.write(135)
writeValue(stream, value.toList())
}
is NdefPigeon -> {
stream.write(136)
writeValue(stream, value.toList())
}
is NfcAPigeon -> {
stream.write(137)
writeValue(stream, value.toList())
}
is NfcBPigeon -> {
stream.write(138)
writeValue(stream, value.toList())
}
is NfcFPigeon -> {
stream.write(139)
writeValue(stream, value.toList())
}
is NfcVPigeon -> {
stream.write(140)
writeValue(stream, value.toList())
}
is IsoDepPigeon -> {
stream.write(141)
writeValue(stream, value.toList())
}
is MifareClassicPigeon -> {
stream.write(142)
writeValue(stream, value.toList())
}
is MifareUltralightPigeon -> {
stream.write(143)
writeValue(stream, value.toList())
}
is NfcBarcodePigeon -> {
stream.write(144)
writeValue(stream, value.toList())
}
is NdefMessagePigeon -> {
stream.write(145)
writeValue(stream, value.toList())
}
is NdefRecordPigeon -> {
stream.write(146)
writeValue(stream, value.toList())
}
else -> super.writeValue(stream, value)
}
}
}
/** Generated class from Pigeon that represents Flutter messages that can be called from Kotlin. */
class FlutterApiPigeon(private val binaryMessenger: BinaryMessenger, private val messageChannelSuffix: String = "") {
companion object {
/** The codec used by FlutterApiPigeon. */
val codec: MessageCodec by lazy {
PigeonPigeonCodec()
}
}
fun onTagDiscovered(tagArg: TagPigeon, callback: (Result) -> Unit)
{
val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
val channelName = "dev.flutter.pigeon.nfc_manager.FlutterApiPigeon.onTagDiscovered$separatedMessageChannelSuffix"
val channel = BasicMessageChannel(binaryMessenger, channelName, codec)
channel.send(listOf(tagArg)) {
if (it is List<*>) {
if (it.size > 1) {
callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))
} else {
callback(Result.success(Unit))
}
} else {
callback(Result.failure(PigeonPigeonUtils.createConnectionError(channelName)))
}
}
}
fun onAdapterStateChanged(stateArg: AdapterStatePigeon, callback: (Result) -> Unit)
{
val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
val channelName = "dev.flutter.pigeon.nfc_manager.FlutterApiPigeon.onAdapterStateChanged$separatedMessageChannelSuffix"
val channel = BasicMessageChannel(binaryMessenger, channelName, codec)
channel.send(listOf(stateArg)) {
if (it is List<*>) {
if (it.size > 1) {
callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))
} else {
callback(Result.success(Unit))
}
} else {
callback(Result.failure(PigeonPigeonUtils.createConnectionError(channelName)))
}
}
}
}
/** Generated interface from Pigeon that represents a handler of messages from Flutter. */
interface HostApiPigeon {
fun nfcAdapterIsEnabled(): Boolean
fun nfcAdapterIsSecureNfcEnabled(): Boolean
fun nfcAdapterIsSecureNfcSupported(): Boolean
fun nfcAdapterEnableReaderMode(flags: List)
fun nfcAdapterDisableReaderMode()
fun ndefGetNdefMessage(handle: String): NdefMessagePigeon?
fun ndefWriteNdefMessage(handle: String, message: NdefMessagePigeon)
fun ndefMakeReadOnly(handle: String): Boolean
fun nfcAGetMaxTransceiveLength(handle: String): Long
fun nfcAGetTimeout(handle: String): Long
fun nfcASetTimeout(handle: String, timeout: Long)
fun nfcATransceive(handle: String, bytes: ByteArray): ByteArray
fun nfcBGetMaxTransceiveLength(handle: String): Long
fun nfcBTransceive(handle: String, bytes: ByteArray): ByteArray
fun nfcFGetMaxTransceiveLength(handle: String): Long
fun nfcFGetTimeout(handle: String): Long
fun nfcFSetTimeout(handle: String, timeout: Long)
fun nfcFTransceive(handle: String, bytes: ByteArray): ByteArray
fun nfcVGetMaxTransceiveLength(handle: String): Long
fun nfcVTransceive(handle: String, bytes: ByteArray): ByteArray
fun isoDepGetMaxTransceiveLength(handle: String): Long
fun isoDepGetTimeout(handle: String): Long
fun isoDepSetTimeout(handle: String, timeout: Long)
fun isoDepTransceive(handle: String, bytes: ByteArray): ByteArray
fun mifareClassicGetMaxTransceiveLength(handle: String): Long
fun mifareClassicGetTimeout(handle: String): Long
fun mifareClassicSetTimeout(handle: String, timeout: Long)
fun mifareClassicBlockToSector(handle: String, blockIndex: Long): Long
fun mifareClassicGetBlockCountInSector(handle: String, sectorIndex: Long): Long
fun mifareClassicSectorToBlock(handle: String, sectorIndex: Long): Long
fun mifareClassicAuthenticateSectorWithKeyA(handle: String, sectorIndex: Long, key: ByteArray): Boolean
fun mifareClassicAuthenticateSectorWithKeyB(handle: String, sectorIndex: Long, key: ByteArray): Boolean
fun mifareClassicIncrement(handle: String, blockIndex: Long, value: Long)
fun mifareClassicDecrement(handle: String, blockIndex: Long, value: Long)
fun mifareClassicReadBlock(handle: String, blockIndex: Long): ByteArray
fun mifareClassicWriteBlock(handle: String, blockIndex: Long, data: ByteArray)
fun mifareClassicRestore(handle: String, blockIndex: Long)
fun mifareClassicTransfer(handle: String, blockIndex: Long)
fun mifareClassicTransceive(handle: String, bytes: ByteArray): ByteArray
fun mifareUltralightGetMaxTransceiveLength(handle: String): Long
fun mifareUltralightGetTimeout(handle: String): Long
fun mifareUltralightSetTimeout(handle: String, timeout: Long)
fun mifareUltralightReadPages(handle: String, pageOffset: Long): ByteArray
fun mifareUltralightWritePage(handle: String, pageOffset: Long, data: ByteArray)
fun mifareUltralightTransceive(handle: String, bytes: ByteArray): ByteArray
fun ndefFormatableFormat(handle: String, firstMessage: NdefMessagePigeon)
fun ndefFormatableFormatReadOnly(handle: String, firstMessage: NdefMessagePigeon)
companion object {
/** The codec used by HostApiPigeon. */
val codec: MessageCodec by lazy {
PigeonPigeonCodec()
}
/** Sets up an instance of `HostApiPigeon` to handle messages through the `binaryMessenger`. */
@JvmOverloads
fun setUp(binaryMessenger: BinaryMessenger, api: HostApiPigeon?, messageChannelSuffix: String = "") {
val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcAdapterIsEnabled$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { _, reply ->
val wrapped: List = try {
listOf(api.nfcAdapterIsEnabled())
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcAdapterIsSecureNfcEnabled$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { _, reply ->
val wrapped: List = try {
listOf(api.nfcAdapterIsSecureNfcEnabled())
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcAdapterIsSecureNfcSupported$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { _, reply ->
val wrapped: List = try {
listOf(api.nfcAdapterIsSecureNfcSupported())
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcAdapterEnableReaderMode$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val flagsArg = args[0] as List
val wrapped: List = try {
api.nfcAdapterEnableReaderMode(flagsArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcAdapterDisableReaderMode$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { _, reply ->
val wrapped: List = try {
api.nfcAdapterDisableReaderMode()
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.ndefGetNdefMessage$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.ndefGetNdefMessage(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.ndefWriteNdefMessage$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val messageArg = args[1] as NdefMessagePigeon
val wrapped: List = try {
api.ndefWriteNdefMessage(handleArg, messageArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.ndefMakeReadOnly$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.ndefMakeReadOnly(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcAGetMaxTransceiveLength$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.nfcAGetMaxTransceiveLength(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcAGetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.nfcAGetTimeout(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcASetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val timeoutArg = args[1] as Long
val wrapped: List = try {
api.nfcASetTimeout(handleArg, timeoutArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcATransceive$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val bytesArg = args[1] as ByteArray
val wrapped: List = try {
listOf(api.nfcATransceive(handleArg, bytesArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcBGetMaxTransceiveLength$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.nfcBGetMaxTransceiveLength(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcBTransceive$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val bytesArg = args[1] as ByteArray
val wrapped: List = try {
listOf(api.nfcBTransceive(handleArg, bytesArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcFGetMaxTransceiveLength$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.nfcFGetMaxTransceiveLength(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcFGetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.nfcFGetTimeout(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcFSetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val timeoutArg = args[1] as Long
val wrapped: List = try {
api.nfcFSetTimeout(handleArg, timeoutArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcFTransceive$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val bytesArg = args[1] as ByteArray
val wrapped: List = try {
listOf(api.nfcFTransceive(handleArg, bytesArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcVGetMaxTransceiveLength$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.nfcVGetMaxTransceiveLength(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.nfcVTransceive$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val bytesArg = args[1] as ByteArray
val wrapped: List = try {
listOf(api.nfcVTransceive(handleArg, bytesArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.isoDepGetMaxTransceiveLength$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.isoDepGetMaxTransceiveLength(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.isoDepGetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.isoDepGetTimeout(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.isoDepSetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val timeoutArg = args[1] as Long
val wrapped: List = try {
api.isoDepSetTimeout(handleArg, timeoutArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.isoDepTransceive$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val bytesArg = args[1] as ByteArray
val wrapped: List = try {
listOf(api.isoDepTransceive(handleArg, bytesArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicGetMaxTransceiveLength$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.mifareClassicGetMaxTransceiveLength(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicGetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.mifareClassicGetTimeout(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicSetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val timeoutArg = args[1] as Long
val wrapped: List = try {
api.mifareClassicSetTimeout(handleArg, timeoutArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicBlockToSector$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val blockIndexArg = args[1] as Long
val wrapped: List = try {
listOf(api.mifareClassicBlockToSector(handleArg, blockIndexArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicGetBlockCountInSector$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val sectorIndexArg = args[1] as Long
val wrapped: List = try {
listOf(api.mifareClassicGetBlockCountInSector(handleArg, sectorIndexArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicSectorToBlock$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val sectorIndexArg = args[1] as Long
val wrapped: List = try {
listOf(api.mifareClassicSectorToBlock(handleArg, sectorIndexArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicAuthenticateSectorWithKeyA$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val sectorIndexArg = args[1] as Long
val keyArg = args[2] as ByteArray
val wrapped: List = try {
listOf(api.mifareClassicAuthenticateSectorWithKeyA(handleArg, sectorIndexArg, keyArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicAuthenticateSectorWithKeyB$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val sectorIndexArg = args[1] as Long
val keyArg = args[2] as ByteArray
val wrapped: List = try {
listOf(api.mifareClassicAuthenticateSectorWithKeyB(handleArg, sectorIndexArg, keyArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicIncrement$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val blockIndexArg = args[1] as Long
val valueArg = args[2] as Long
val wrapped: List = try {
api.mifareClassicIncrement(handleArg, blockIndexArg, valueArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicDecrement$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val blockIndexArg = args[1] as Long
val valueArg = args[2] as Long
val wrapped: List = try {
api.mifareClassicDecrement(handleArg, blockIndexArg, valueArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicReadBlock$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val blockIndexArg = args[1] as Long
val wrapped: List = try {
listOf(api.mifareClassicReadBlock(handleArg, blockIndexArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicWriteBlock$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val blockIndexArg = args[1] as Long
val dataArg = args[2] as ByteArray
val wrapped: List = try {
api.mifareClassicWriteBlock(handleArg, blockIndexArg, dataArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicRestore$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val blockIndexArg = args[1] as Long
val wrapped: List = try {
api.mifareClassicRestore(handleArg, blockIndexArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicTransfer$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val blockIndexArg = args[1] as Long
val wrapped: List = try {
api.mifareClassicTransfer(handleArg, blockIndexArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareClassicTransceive$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val bytesArg = args[1] as ByteArray
val wrapped: List = try {
listOf(api.mifareClassicTransceive(handleArg, bytesArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareUltralightGetMaxTransceiveLength$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.mifareUltralightGetMaxTransceiveLength(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareUltralightGetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val wrapped: List = try {
listOf(api.mifareUltralightGetTimeout(handleArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareUltralightSetTimeout$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val timeoutArg = args[1] as Long
val wrapped: List = try {
api.mifareUltralightSetTimeout(handleArg, timeoutArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareUltralightReadPages$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val pageOffsetArg = args[1] as Long
val wrapped: List = try {
listOf(api.mifareUltralightReadPages(handleArg, pageOffsetArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareUltralightWritePage$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val pageOffsetArg = args[1] as Long
val dataArg = args[2] as ByteArray
val wrapped: List = try {
api.mifareUltralightWritePage(handleArg, pageOffsetArg, dataArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.mifareUltralightTransceive$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val bytesArg = args[1] as ByteArray
val wrapped: List = try {
listOf(api.mifareUltralightTransceive(handleArg, bytesArg))
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.ndefFormatableFormat$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val firstMessageArg = args[1] as NdefMessagePigeon
val wrapped: List = try {
api.ndefFormatableFormat(handleArg, firstMessageArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
run {
val channel = BasicMessageChannel(binaryMessenger, "dev.flutter.pigeon.nfc_manager.HostApiPigeon.ndefFormatableFormatReadOnly$separatedMessageChannelSuffix", codec)
if (api != null) {
channel.setMessageHandler { message, reply ->
val args = message as List
val handleArg = args[0] as String
val firstMessageArg = args[1] as NdefMessagePigeon
val wrapped: List = try {
api.ndefFormatableFormatReadOnly(handleArg, firstMessageArg)
listOf(null)
} catch (exception: Throwable) {
PigeonPigeonUtils.wrapError(exception)
}
reply.reply(wrapped)
}
} else {
channel.setMessageHandler(null)
}
}
}
}
}
================================================
FILE: android/src/test/kotlin/dev/flutter/plugins/nfcmanager/NfcManagerPluginTest.kt
================================================
package dev.flutter.plugins.nfcmanager
internal class NfcManagerPluginTest {}
================================================
FILE: example/.gitignore
================================================
# Miscellaneous
*.class
*.log
*.pyc
*.swp
.DS_Store
.atom/
.build/
.buildlog/
.history
.svn/
.swiftpm/
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-dependencies
.pub-cache/
.pub/
/build/
/coverage/
# 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
================================================
FILE: example/README.md
================================================
# nfc_manager_example
Demonstrates how to use the nfc_manager plugin.
## Getting Started
This project is a starting point for a Flutter application.
A few resources to get you started if this is your first Flutter project:
- [Learn Flutter](https://docs.flutter.dev/get-started/learn-flutter)
- [Write your first Flutter app](https://docs.flutter.dev/get-started/codelab)
- [Flutter learning resources](https://docs.flutter.dev/reference/learning-resources)
For help getting started with Flutter development, view the
[online documentation](https://docs.flutter.dev/), which offers tutorials,
samples, guidance on mobile development, and a full API reference.
================================================
FILE: example/analysis_options.yaml
================================================
include: package:flutter_lints/flutter.yaml
================================================
FILE: example/android/.gitignore
================================================
gradle-wrapper.jar
/.gradle
/captures/
/gradlew
/gradlew.bat
/local.properties
GeneratedPluginRegistrant.java
.cxx/
# Remember to never publicly share your keystore.
# See https://flutter.dev/to/reference-keystore
key.properties
**/*.keystore
**/*.jks
================================================
FILE: example/android/app/build.gradle.kts
================================================
plugins {
id("com.android.application")
id("kotlin-android")
// The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins.
id("dev.flutter.flutter-gradle-plugin")
}
android {
namespace = "dev.flutter.plugins.nfcmanagerexample"
compileSdk = flutter.compileSdkVersion
ndkVersion = flutter.ndkVersion
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
kotlinOptions {
jvmTarget = JavaVersion.VERSION_17.toString()
}
defaultConfig {
// TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
applicationId = "dev.flutter.plugins.nfcmanagerexample"
// You can update the following values to match your application needs.
// For more information, see: https://flutter.dev/to/review-gradle-config.
minSdk = flutter.minSdkVersion
targetSdk = flutter.targetSdkVersion
versionCode = flutter.versionCode
versionName = flutter.versionName
}
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.getByName("debug")
}
}
}
flutter {
source = "../.."
}
================================================
FILE: example/android/app/src/debug/AndroidManifest.xml
================================================
================================================
FILE: example/android/app/src/main/AndroidManifest.xml
================================================
================================================
FILE: example/android/app/src/main/kotlin/dev/flutter/plugins/nfcmanagerexample/MainActivity.kt
================================================
package dev.flutter.plugins.nfcmanagerexample
import io.flutter.embedding.android.FlutterActivity
class MainActivity : FlutterActivity()
================================================
FILE: example/android/app/src/main/res/drawable/launch_background.xml
================================================