Integrasi Flutter dengan Library Reader Handheld §

...
 
// Add /.jar file
dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'libs')
}

buildTypes {
	release {
		// TODO: Add your own signing config for the release build.
		// Signing with the debug keys for now, so `flutter run --release` works.
		signingConfig signingConfigs.debug
		proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' // Add proguard-rules.pro
	}
}

import 'package:pigeon/pigeon.dart';
 
class ReaderPower {
  int? readPower;
  int? writePower;
}
 
class InventoryResult {
  String? epc;
  int? rssi;
}
 
@HostApi()
abstract class ReaderApi {
  @async
  bool init();
 
  @async
  ReaderPower? getPower();
 
  @async
  bool setPower(int readPower, int writePower);
 
  @async
  bool writeEpc(String currentEpc, String toWriteEpc, String accessPassowrd);
 
  @async
  List<InventoryResult?> inventory();
 
  @async
  bool dispose();
}

// MainActivity.java
 
package com.example.flutter_tutorial_el_uhf_rh02;
 
import android.view.KeyEvent;
import android.util.Log;
import android.os.Handler;
import android.os.Looper;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
 
import androidx.annotation.NonNull;
 
import cn.pda.serialport.Tools;
import io.flutter.plugin.common.BinaryMessenger;
import io.flutter.plugin.common.EventChannel;
import io.flutter.plugin.common.EventChannel.EventSink;
import io.flutter.plugin.common.EventChannel.StreamHandler;
import io.flutter.embedding.android.FlutterActivity;
import io.flutter.embedding.engine.FlutterEngine;
 
import com.handheld.uhfr.UHFRManager;
import com.uhf.api.cls.Reader;
 
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import io.flutter.plugins.Pigeon.Result;
import io.flutter.plugins.Pigeon.NullableResult;
import io.flutter.plugins.Pigeon.ReaderApi;
import io.flutter.plugins.Pigeon.InventoryResult;
import io.flutter.plugins.Pigeon.ReaderPower;
 
public class MainActivity extends FlutterActivity {
    private static final String TAG = "MainActivity";
    private static UHFRManager uhfrManager;
 
    private BinaryMessenger messenger;
    private EventChannel fireButtonEventChannel;
    private EventSink fireButtonEventSink;
 
    @Override
    public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
        super.configureFlutterEngine(flutterEngine);
        Log.d(TAG, "configureFlutterEngine");
 
        String packageName = getApplicationContext().getPackageName();
        messenger = flutterEngine.getDartExecutor().getBinaryMessenger();
 
        // Set up Pigeon-generated ReaderApi
        ReaderApi.setUp(messenger, new ReaderApiHandler());
 
        // Set up EventChannel for fire button
        fireButtonEventChannel = new EventChannel(messenger, packageName + "/fire_button");
        fireButtonEventChannel.setStreamHandler(fireButtonStreamHandler);
    }
 
    // Handler class for ReaderApi methods
    public class ReaderApiHandler implements ReaderApi {
 
        // Init - Init library variable (UHFRManager) and check if connect to reader
        @Override
        public void init(Result<Boolean> callback) {
            Log.d(TAG, "ReaderApiHandler.init");
 
            uhfrManager = UHFRManager.getInstance();
            if (uhfrManager == null || uhfrManager.getHardware() == null) {
                callback.error(new Exception("Failed to initialize reader (can't get hardware version)"));
                return;
            }
 
            uhfrManager.setGen2session(false);
            callback.success(true);
        }
 
        // Inventory
        @Override
        public void inventory(Result<List<InventoryResult>> callback) {
            new Thread(() -> {
                uhfrManager.setCancleInventoryFilter();
                uhfrManager.setGen2session(false);
 
                List<InventoryResult> inventoryResults = new ArrayList<>();
                List<Reader.TAGINFO> tags = uhfrManager.tagInventoryByTimer((short) 100);
 
                if (tags != null) {
                    for (Reader.TAGINFO tag : tags) {
                        InventoryResult inventoryResult = new InventoryResult();
                        inventoryResult.setEpc(Tools.Bytes2HexString(tag.EpcId, tag.EpcId.length));
                        inventoryResult.setRssi((long) tag.RSSI);
                        inventoryResults.add(inventoryResult);
                    }
                }
 
                callback.success(inventoryResults);
            }).start();
        }
 
        // Get power
        @Override
        public void getPower(NullableResult<ReaderPower> callback) {
            int[] power = uhfrManager.getPower();
            if (power != null) {
                ReaderPower readerPower = new ReaderPower();
                readerPower.setReadPower((long) power[0]);
                readerPower.setWritePower((long) power[1]);
                callback.success(readerPower);
                return;
            }
 
            callback.error(new Exception("Failed to get reader power"));
        }
 
        // Set power
        @Override
        public void setPower(Long readPower, Long writePower, Result<Boolean> callback) {
            Reader.READER_ERR response = uhfrManager.setPower(readPower.intValue(), writePower.intValue());
            if (response == Reader.READER_ERR.MT_OK_ERR) {
                callback.success(true);
                return;
            }
 
            callback.error(new Exception("Failed to set reader power"));
        }
 
        // Write EPC
        @Override
        public void writeEpc(String currentEpc, String toWriteEpc, String accessPassword,
                Result<Boolean> callback) {
            new Thread(() -> {
                byte[] currentEpcBytes = Tools.HexString2Bytes(currentEpc);
                byte[] toWriteEpcBytes = Tools.HexString2Bytes(toWriteEpc);
                byte[] accessPasswordBytes = Tools.HexString2Bytes(accessPassword);
 
                Reader.READER_ERR response = uhfrManager.writeTagDataByFilter((char) 1, 2, toWriteEpcBytes,
                        toWriteEpcBytes.length, accessPasswordBytes, (short) 3000,
                        currentEpcBytes, 1, 2, true);
 
                if (response == Reader.READER_ERR.MT_OK_ERR) {
                    callback.success(true);
                    return;
                }
 
                callback.success(false);
            }).start();
        }
 
        // Dispose, close the library variable
        @Override
        public void dispose(Result<Boolean> callback) {
            uhfrManager.close();
            callback.success(true);
        }
    }
 
    // StreamHandler for the fire button
    private final StreamHandler fireButtonStreamHandler = new StreamHandler() {
        private final BroadcastReceiver fireButtonReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                int keyCode = intent.getIntExtra("keyCode", intent.getIntExtra("keycode", 0));
                boolean keyDown = intent.getBooleanExtra("keydown", false);
 
                if (keyCode == KeyEvent.KEYCODE_F4) {
                    Map<String, Object> keyShootMap = new HashMap<>();
                    keyShootMap.put("key_code", keyCode);
                    keyShootMap.put("key_down", keyDown);
                    fireButtonEventSink.success(keyShootMap);
                }
            }
        };
 
        @Override
        public void onListen(Object args, EventSink eventSink) {
            fireButtonEventSink = new EventSinkWrapper(eventSink);
 
            IntentFilter filter = new IntentFilter("android.rfid.FUN_KEY");
            registerReceiver(fireButtonReceiver, filter);
 
            Log.d(TAG, "fireButtonStreamHandler.onListen");
        }
 
        @Override
        public void onCancel(Object args) {
            fireButtonEventSink = null;
            Log.d(TAG, "fireButtonStreamHandler.onCancel");
        }
    };
 
    // Wrapper for EventSink to ensure execution on the main thread
    private static class EventSinkWrapper implements EventSink {
        private final EventSink eventSink;
        private final Handler handler = new Handler(Looper.getMainLooper());
 
        EventSinkWrapper(EventSink eventSink) {
            this.eventSink = eventSink;
        }
 
        @Override
        public void success(Object result) {
            handler.post(() -> eventSink.success(result));
        }
 
        @Override
        public void error(@NonNull String errorCode, String errorMessage, Object errorDetails) {
            handler.post(() -> eventSink.error(errorCode, errorMessage, errorDetails));
        }
 
        @Override
        public void endOfStream() {
            handler.post(eventSink::endOfStream);
        }
    }
}