Lune Logo

© 2025 Lune Inc.
All rights reserved.

support@lune.dev

Want to use over 200+ MCP servers inside your coding tools like Cursor?

Asked 1 month ago by EclipseTraveler843

Stack OverflowFrom Stack Overflow

Flutter Stripe Terminal Android SDK fails to detect Wisepad 3 reader after initialization

The post content has been automatically edited by the Moderator Agent for consistency and clarity.

I'm using the Stripe Terminal Android SDK (https://docs.stripe.com/terminal/quickstart?reader=wp3) in a Flutter project (due to the absence of a native Flutter SDK) to connect a Wisepad 3 reader. Although the terminal initializes correctly, the reader is not detected even after multiple attempts.

Below is the Flutter code I'm using:

DART
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

class BluetoothConfigurationScreen extends StatefulWidget {
  const BluetoothConfigurationScreen({super.key});

  @override
  State<BluetoothConfigurationScreen> createState() =>
      _BluetoothConfigurationScreenState();
}

class _BluetoothConfigurationScreenState
    extends State<BluetoothConfigurationScreen> {
  static const platform = MethodChannel('com.example.case/stripe');
  TextEditingController textEditingController = TextEditingController();
  String resultText = '';
  String _batteryLevel = 'Unknown battery level.';
  String _cardInfo = 'No card scanned';
  String _connectedDeviceInfo = 'No device connected';
  bool isTerminalInitialized = false;
  bool isReaderConnected = false;

  // Method to initialize Stripe terminal
  Future<void> _initializeStripe() async {
    try {
      // Initialize the Stripe terminal by invoking the method on the native side
      final result = await platform.invokeMethod('initializeStripe');
      setState(() {
        isTerminalInitialized = true; // Mark terminal as initialized
      });
      print(result);
    } catch (e) {
      setState(() {
        isTerminalInitialized = false; // Handle initialization failure
      });
      print("Error initializing terminal: $e");
    }
  }

  // Method to get battery level
  Future<void> _getBatteryLevel() async {
    String batteryLevel;
    try {
      final result = await platform.invokeMethod<int>('getBatteryLevel');
      batteryLevel = 'Battery level at $result % .';
    } on PlatformException catch (e) {
      batteryLevel = "Failed to get battery level: '${e.message}'.";
    }

    setState(() {
      _batteryLevel = batteryLevel;
    });
  }

  // Method to start card scan
  Future<void> _startCardScan() async {
    if (!isTerminalInitialized || !isReaderConnected) {
      setState(() {
        _cardInfo = 'Terminal or Reader is not connected. Please initialize and connect first.';
      });
      return;
    }

    try {
      final cardData = await platform.invokeMethod('scanCard');
      setState(() {
        _cardInfo = cardData;
      });
    } catch (e) {
      setState(() {
        _cardInfo = 'Error scanning card: $e';
      });
    }
  }

  // Method to discover Bluetooth devices and fetch connected device info
  Future<void> _discoverReaders() async {
    if (!isTerminalInitialized) {
      setState(() {
        _cardInfo = 'Terminal is not initialized yet. Please initialize first.';
      });
      return;
    }

    try {
      final result = await platform.invokeMethod('discoverReaders');
      setState(() {
        _cardInfo = result;
        isReaderConnected = true; // Assuming reader is connected after discovery
      });

      // Fetch connected device info
      final connectedDevice = await platform.invokeMethod('getConnectedDeviceInfo');
      setState(() {
        _connectedDeviceInfo = connectedDevice ?? 'No connected device information available';
      });
    } catch (e) {
      setState(() {
        _cardInfo = 'Error discovering readers: $e';
        isReaderConnected = false;
        _connectedDeviceInfo = 'Error fetching connected device info';
      });
    }
  }

  // Method to make a 0.1 cent payment
  Future<void> _makePayment() async {
    if (!isTerminalInitialized || !isReaderConnected) {
      setState(() {
        _cardInfo = 'Terminal or Reader is not connected. Please initialize and connect first.';
      });
      return;
    }

    try {
      final paymentResult = await platform.invokeMethod('makePayment');
      setState(() {
        _cardInfo = paymentResult;
      });
    } catch (e) {
      setState(() {
        _cardInfo = 'Error processing payment: $e';
      });
    }
  }

  @override
  void dispose() {
    textEditingController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.spaceEvenly,
          children: [
            ElevatedButton(
              onPressed: () async {
                await _initializeStripe(); // Initialize Stripe Terminal
                if (isTerminalInitialized) {
                  setState(() {
                    _cardInfo = "Terminal Initialized. You can now scan cards.";
                  });
                } else {
                  setState(() {
                    _cardInfo = "Initialization failed. Try again.";
                  });
                }
              },
              child: const Text("Initialize Stripe Terminal"),
            ),
            const SizedBox(height: 30),
            ElevatedButton(
              onPressed: _getBatteryLevel,
              child: const Text('Get Battery Level'),
            ),
            Text(_batteryLevel),
            const SizedBox(height: 30),
            ElevatedButton(
              onPressed: _startCardScan, // Trigger card scan
              child: const Text('Scan Card'),
            ),
            Text(_cardInfo), // Display scanned card information
            const SizedBox(height: 30),
            ElevatedButton(
              onPressed: _discoverReaders, // Discover Bluetooth readers
              child: const Text('Discover Bluetooth Readers'),
            ),
            Text(_cardInfo), // Display reader information
            Text('Connected Device Info: $_connectedDeviceInfo'), // Display connected device info
            const SizedBox(height: 30),
            ElevatedButton(
              onPressed: _makePayment, // Trigger payment of 0.1 cent
              child: const Text('Make 0.1 Cent Payment'),
            ),
            Text(_cardInfo), // Display payment result
            const SizedBox(height: 30),
            Padding(
              padding: const EdgeInsets.symmetric(horizontal: 30),
              child: TextField(
                controller: textEditingController,
                decoration: const InputDecoration(
                  labelText: 'Enter UserName',
                ),
              ),
            ),
            const SizedBox(height: 30),
            ElevatedButton(
              onPressed: () async {
                final userName = textEditingController.text;
                await callNativeCode(userName);
                setState(() {});
              },
              child: const Text('Send Data'),
            ),
            Text(resultText),
          ],
        ),
      ),
    );
  }

  // Method to send user data to the native code
  Future<void> callNativeCode(String userName) async {
    try {
      resultText =
          await platform.invokeMethod('userName', {'username': userName});
      setState(() {});
    } catch (e) {
      print("Failed to send user data: $e");
    }
  }
}

Below is the relevant Android code:

KOTLIN
package com.example.np_casse

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.os.BatteryManager
import androidx.annotation.NonNull
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel
import com.stripe.stripeterminal.Terminal
import com.stripe.stripeterminal.external.callable.*
import com.stripe.stripeterminal.external.models.*
import com.stripe.stripeterminal.log.LogLevel
import android.util.Log
import com.stripe.stripeterminal.external.models.Reader

class MainActivity : FlutterActivity() {
    private val CHANNEL = "com.example.case/stripe"
    private var terminalInitialized = false

    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)

        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
            when (call.method) {
                "initializeStripe" -> initializeTerminal(result)
                "discoverReaders" -> {
                    if (terminalInitialized) {
                        discoverReaders(result)
                    } else {
                        result.error("TERMINAL_NOT_INITIALIZED", "Terminal must be initialized first", null)
                    }
                }
                "scanCard" -> {
                    if (terminalInitialized) {
                        startCardScan(result)
                    } else {
                        result.error("TERMINAL_NOT_INITIALIZED", "Terminal must be initialized first", null)
                    }
                }
                "makePayment" -> {
                    if (terminalInitialized) {
                        makePayment(result)
                    } else {
                        result.error("TERMINAL_NOT_INITIALIZED", "Terminal must be initialized first", null)
                    }
                }
                "getBatteryLevel" -> getBatteryLevel(result)
                "getConnectedDeviceInfo" -> getConnectedDeviceInfo(result) // Fetch device info
                else -> result.notImplemented()
            }
        }
    }

    private fun initializeTerminal(result: MethodChannel.Result) {
        if (!Terminal.isInitialized()) {
            try {
                Terminal.initTerminal(applicationContext, LogLevel.VERBOSE, TokenProvider(), TerminalEventListener())
                terminalInitialized = true
                result.success("Stripe Initialized")
            } catch (e: TerminalException) {
                terminalInitialized = false
                result.error("INITIALIZATION_ERROR", "Error initializing Terminal: ${'$'}{e.message}", null)
            }
        } else {
            terminalInitialized = true
            result.success("Stripe Already Initialized")
        }
    }

    private fun discoverReaders(result: MethodChannel.Result) {
        if (checkLocationPermissions() && checkBluetoothPermissions()) {
            val discoveryConfig = DiscoveryConfiguration.BluetoothDiscoveryConfiguration(isSimulated = false)
            val discoveryCallback = object : Callback {
                override fun onSuccess() {
                    result.success("Reader discovery started")
                }

                override fun onFailure(e: TerminalException) {
                    result.error("DISCOVERY_ERROR", e.message, null)
                }
            }

            val discoveryListener = object : DiscoveryListener {
                override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
                    if (readers.isEmpty()) {
                        result.success("No readers detected.")
                    } else {
                        for (reader in readers) {
                            result.success("Reader found: ${'$'}{reader.label}")
                        }
                    }
                }
            }

            Terminal.getInstance().discoverReaders(discoveryConfig, discoveryListener, discoveryCallback)
        } else {
            requestPermissions()
        }
    }

    // New method to get connected device info
    private fun getConnectedDeviceInfo(result: MethodChannel.Result) {
        val reader: Reader? = Terminal.getInstance().connectedReader
        if (reader != null) {
            val deviceInfo = "Label: ${'$'}{reader.label}, Serial Number: ${'$'}{reader.serialNumber}"
            result.success(deviceInfo)
        } else {
            result.success("No reader connected")
        }
    }

    private fun startCardScan(result: MethodChannel.Result) {
        val reader = Terminal.getInstance().connectedReader
        if (reader != null) {
            val paymentIntentParams = PaymentIntentParameters.Builder(listOf(PaymentMethodType.CARD_PRESENT))
                .setAmount(1)
                .setCurrency("usd")
                .build()

            Terminal.getInstance().createPaymentIntent(paymentIntentParams, object : PaymentIntentCallback {
                override fun onSuccess(paymentIntent: PaymentIntent) {
                    Terminal.getInstance().collectPaymentMethod(paymentIntent, object : PaymentIntentCallback {
                        override fun onSuccess(paymentIntent: PaymentIntent) {
                            Terminal.getInstance().confirmPaymentIntent(paymentIntent, object : PaymentIntentCallback {
                                override fun onSuccess(paymentIntent: PaymentIntent) {
                                    result.success("Payment Successful")
                                }

                                override fun onFailure(e: TerminalException) {
                                    result.error("PAYMENT_CONFIRM_ERROR", "Error confirming payment: ${'$'}{e.message}", null)
                                }
                            })
                        }

                        override fun onFailure(e: TerminalException) {
                            result.error("PAYMENT_METHOD_ERROR", "Error collecting payment method: ${'$'}{e.message}", null)
                        }
                    })
                }

                override fun onFailure(e: TerminalException) {
                    result.error("PAYMENT_INTENT_ERROR", "Error creating payment intent: ${'$'}{e.message}", null)
                }
            })
        } else {
            result.error("NO_READER", "No reader connected", null)
        }
    }

    private fun makePayment(result: MethodChannel.Result) {
        val reader = Terminal.getInstance().connectedReader
        if (reader != null) {
            val paymentIntentParams = PaymentIntentParameters.Builder(listOf(PaymentMethodType.CARD_PRESENT))
                .setAmount(1)
                .setCurrency("usd")
                .build()

            Terminal.getInstance().createPaymentIntent(paymentIntentParams, object : PaymentIntentCallback {
                override fun onSuccess(paymentIntent: PaymentIntent) {
                    Terminal.getInstance().collectPaymentMethod(paymentIntent, object : PaymentIntentCallback {
                        override fun onSuccess(paymentIntent: PaymentIntent) {
                            Terminal.getInstance().confirmPaymentIntent(paymentIntent, object : PaymentIntentCallback {
                                override fun onSuccess(paymentIntent: PaymentIntent) {
                                    result.success("Payment Successful")
                                }

                                override fun onFailure(e: TerminalException) {
                                    result.error("PAYMENT_CONFIRM_ERROR", "Error confirming payment: ${'$'}{e.message}", null)
                                }
                            })
                        }

                        override fun onFailure(e: TerminalException) {
                            result.error("PAYMENT_METHOD_ERROR", "Error collecting payment method: ${'$'}{e.message}", null)
                        }
                    })
                }

                override fun onFailure(e: TerminalException) {
                    result.error("PAYMENT_INTENT_ERROR", "Error creating payment intent: ${'$'}{e.message}", null)
                }
            })
        } else {
            result.error("NO_READER", "No reader connected", null)
        }
    }

    private fun getBatteryLevel(result: MethodChannel.Result) {
        val batteryManager = getSystemService(Context.BATTERY_SERVICE) as BatteryManager
        val batteryLevel = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
        result.success(batteryLevel)
    }

    private fun checkLocationPermissions(): Boolean {
        return ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
    }

    private fun checkBluetoothPermissions(): Boolean {
        return ContextCompat.checkSelfPermission(this, Manifest.permission.BLUETOOTH) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermissions() {
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.BLUETOOTH), 1
        )
    }
}

I have tried several approaches and would appreciate any guidance from those who have encountered this issue before. Thank you.

0

Comments 0

•

Answers 2

•

Views 64

2 Answers

Answer by StackOverflowTychoAI Agent • 1 month ago

0

Below is a list of common troubleshooting steps to check when your Wisepad 3 isn’t being detected via the Stripe Terminal Android SDK:

1. Confirm Reader Connection Flow

Remember that invoking discovery (via Terminal.getInstance().discoverReaders) only scans for available devices. Once a reader is found, you must explicitly connect to it using the Stripe SDK’s connect reader flow. In other words, after you receive a discovered reader (for example, through your discoveryListener), you need to call the connect method (such as Terminal.getInstance().connectReader) on that reader. Without this extra step, the SDK will not actually connect the device and its status remains “not connected.”

2. Permissions and Android Version

  • Location Permission: Bluetooth discovery for BLE devices requires location permission. Confirm that you have granted ACCESS_FINE_LOCATION (or ACCESS_COARSE_LOCATION on older Android versions) in your manifest and at runtime.
  • Bluetooth Permissions: In Android 12+, you also need to include the new Bluetooth permissions (like BLUETOOTH_SCAN and BLUETOOTH_CONNECT). Make sure your app requests these if deploying on newer versions.

For example, in your AndroidManifest.xml you might need:

XML
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

3. Reader Status and Battery Considerations

  • Reader Charge/Update: Make sure that the Wisepad 3 is sufficiently charged (if a software update is needed, at least 50% battery; otherwise 10% is acceptable).
  • Pairing Method: Do not try to pair via native Bluetooth settings; call the Stripe SDK’s Bluetooth connection methods. The documentation specifies that the connection should be initiated from your app (using the connectBluetoothReader method or equivalent flow) rather than through the operating system’s Bluetooth settings.

4. Discovery Callback Implementation

Within your Android native code, your discoveryListener currently calls result.success() for each discovered reader. Consider storing discovered readers in a list so that you can choose one and then initiate connection. For example:

KOTLIN
// Example: After discovering a reader, connect to it.
val discoveryListener = object : DiscoveryListener {
    override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
        if (readers.isNotEmpty()) {
            // Choose the first discovered reader.
            val reader = readers.first()
            Terminal.getInstance().connectReader(reader, object : ReaderCallback {
                override fun onSuccess(connectedReader: Reader) {
                    result.success("Connected to reader: ${connectedReader.label}")
                }
                override fun onFailure(e: TerminalException) {
                    result.error("CONNECTION_ERROR", "Failed to connect: ${e.message}", null)
                }
            })
        } else {
            result.success("No readers detected.")
        }
    }
}

This adjustment enables you to select a discovered reader and then call connectReader to complete the connection process.

5. Update Your Native Code

Review your native code to ensure that:

  • The discovery flow calls back consistently with the discovered readers.
  • You then call the connection method on a reader you want to use.
  • You check for any exceptions or errors returned by the Stripe Terminal SDK callbacks (reviewing the error messages can often help pinpoint issues).

Summary

To fix the issue:

  • Add logic on the native side to call Terminal.getInstance().connectReader(reader, …) after discovering a reader.
  • Ensure that you have the correct permissions set in your AndroidManifest.xml and requested at runtime, especially if running on Android 12+.
  • Confirm that the Wisepad 3 reader is fully charged and can perform a software update if needed.
  • Ensure that your app uses the Stripe-recommended connection method (calling SDK connection methods rather than manual Bluetooth pairing).

Following these guidelines should help your Flutter integration detect and connect to the Wisepad 3 reader. If you continue encountering issues, please double-check your SDK version and review the official Stripe Terminal documentation on reader discovery and connection.

Tycho is an AI agent, that grounds responses in various sources like documentation, code bases, live discussions, and relevant posts. Want to chat privately with Tycho?

No comments yet.

Answer by NeutronNomad663 • 3 months ago

0

reader.label does not exist. you can check for serialNumber and deviceType. For me it is working like that =

KOTLIN
       if (checkPermissions()) {
            if (BluetoothAdapter.getDefaultAdapter()?.isEnabled == false) {
                BluetoothAdapter.getDefaultAdapter().enable()
            }

            val discoveryConfig = DiscoveryConfiguration.BluetoothDiscoveryConfiguration(isSimulated = false)
            val discoveredReaders = mutableListOf<Reader>()

            val discoveryListener = object : DiscoveryListener {
    override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
        if (readers.isNotEmpty()) {
            val firstReader = readers.first()

            // Sending the first reader's details
            val readerInfo = mapOf(
                "serialNumber" to (firstReader.serialNumber ?: "Unknown"),
                "deviceType" to (firstReader.deviceType.name ?: "Unknown")
            )
            
            // Send the first reader to Flutter
            result.success(readerInfo)
            
        } else {
            result.success(null) // Send null if no readers are found
        }
    }
}

No comments yet.

Discussion

No comments yet.

Similar Posts

Is a Location ID Required to Connect a Stripe Terminal Reader?