Flutter插件seeso_flutter的使用_seeso_flutter是一个用于实时计算用户视线位置的眼动追踪库。所有计算都在设备上本地完成

seeso_flutter 是一个用于实时计算用户视线位置的眼动追踪库。所有计算都在设备上本地完成。

Flutter插件seeso_flutter潜在用途

眼动追踪技术可以应用于多个领域，例如：

用户体验研究：通过分析用户在屏幕上的注视点来改进界面设计。
游戏开发：在游戏中使用用户的视线作为输入，实现更自然的交互方式。
辅助技术：帮助行动不便的人通过眼睛控制设备。
广告效果评估：分析用户对广告的关注度，优化广告策略。

Flutter功能扩展插件seeso_flutter的使用

以下是 seeso_flutter 插件的基本使用步骤和示例代码。

1. Flutter插件seeso_flutter安装

首先，确保你的开发环境已经安装了 Flutter。然后创建一个新的 Flutter 项目：

flutter create --platforms android,ios sample_app

在 sample_app 的 pubspec.yaml 文件中添加 seeso_flutter 依赖：

dependencies:
  flutter:
    sdk: flutter
  seeso_flutter: ^1.0.4

接着运行以下命令安装依赖：

flutter pub get

Android 配置

在 android/build.gradle 文件中添加 Maven 仓库：

allprojects {
    repositories {
        ...
        maven {
            url "https://seeso.jfrog.io/artifactory/visualcamp-seeso-android-gradle-release/"
        }
    }
}

在 android/app/build.gradle 文件中添加必要的依赖：

dependencies {
  ...
  implementation "camp.visual:seeso-gazetracker:latest.release"
  implementation "camp.visual:seeso-libgaze:latest.release"
}

iOS 配置

在 ios/Info.plist 文件中添加相机权限请求：

<key>NSCameraUsageDescription</key>
<string></string>

在 ios/Podfile 中添加相机权限定义：

target.build_configurations.each do |config|
    config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
      '$(inherited)',
      ...
      'PERMISSION_CAMERA=1'
    ]
end

然后运行以下命令安装依赖：

pod install

2. 获取许可证密钥

seeso_sdk 需要一个许可证密钥才能运行。你可以从 seeso.io 获取密钥。

3. 如何使用

以下是一个完整的示例代码，展示了如何使用 seeso_flutter 插件。

import 'package:flutter/material.dart';
import 'dart:async';

import 'package:flutter/services.dart';
import 'package:seeso_flutter/event/calibration_info.dart';
import 'package:seeso_flutter/event/gaze_info.dart';
import 'package:seeso_flutter/event/status_info.dart';
import 'package:seeso_flutter/seeso.dart';
import 'package:seeso_flutter/seeso_initialized_result.dart';
import 'package:seeso_flutter/seeso_plugin_constants.dart';

void main() {
  runApp(const MyApp());
}

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

  [@override](/user/override)
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  final _seesoPlugin = SeeSo();
  // todo 输入您的许可证密钥
  static const String _licenseKey = "输入您的许可证密钥";

  String _version = "未知";
  String _hasCameraPermissionString = "未授权";
  String _stateString = "空闲";
  String _trackingBtnText = "停止跟踪";
  bool _hasCameraPermission = false;
  bool _isInitialied = false;
  bool _showingGaze = false;
  bool _isCaliMode = false;

  double _x = 0.0, _y = 0.0;
  MaterialColor _gazeColor = Colors.red;
  double _nextX = 0, _nextY = 0, _calibrationProgress = 0.0;

  [@override](/user/override)
  void initState() {
    super.initState();
    getSeeSoVersion();
    initSeeSo();
  }

  Future<void> checkCameraPermission() async {
    _hasCameraPermission = await _seesoPlugin.checkCameraPermission();
    if (!_hasCameraPermission) {
      _hasCameraPermission = await _seesoPlugin.requestCameraPermission();
    }
    if (!mounted) {
      return;
    }

    setState(() {
      _hasCameraPermissionString = _hasCameraPermission ? "已授权" : "未授权";
    });
  }

  Future<void> initSeeSo() async {
    await checkCameraPermission();
    String requestInitGazeTracker = "初始化请求失败";
    if (_hasCameraPermission) {
      try {
        InitializedResult? initializedResult =
            await _seesoPlugin.initGazeTracker(licenseKey: _licenseKey);

        setState(() {
          _isInitialied = initializedResult!.result;
          _stateString = initializedResult.message;
        });
        if (initializedResult!.result) {
          listenEvents();
          try {
            _seesoPlugin.startTracking();
          } on PlatformException catch (e) {
            setState(() {
              _stateString = "发生平台异常 (${e.message})";
            });
          }
        }
      } on PlatformException catch (e) {
        requestInitGazeTracker = "发生平台异常 (${e.message})";
        setState(() {
          _isInitialied = false;
          _stateString = requestInitGazeTracker;
        });
      }
    }
  }

  void _trackingBtnPressed() {
    if (_isInitialied) {
      if (_trackingBtnText == "开始跟踪") {
        try {
          _seesoPlugin.startTracking(); // 调用函数开始跟踪
          _trackingBtnText = "停止跟踪";
        } on PlatformException catch (e) {
          setState(() {
            _stateString = "发生平台异常 (${e.message})";
          });
        }
      } else {
        try {
          _seesoPlugin.stopTracking(); // 调用函数停止跟踪
          _trackingBtnText = "开始跟踪";
        } on PlatformException catch (e) {
          setState(() {
            _stateString = "发生平台异常 (${e.message})";
          });
        }
      }
      setState(() {
        _trackingBtnText = _trackingBtnText;
      });
    }
  }

  void _calibrationBtnPressed() {
    if (_isInitialied) {
      try {
        _seesoPlugin.startCalibration(CalibrationMode.FIVE);
        setState(() {
          _isCaliMode = true;
        });
      } on PlatformException catch (e) {
        setState(() {
          _stateString = "发生平台异常 (${e.message})";
        });
      }
    }
  }

  void listenEvents() {
    _seesoPlugin.getGazeEvent().listen((event) {
      GazeInfo info = GazeInfo(event);

      if (info.trackingState == TrackingState.SUCCESS) {
        setState(() {
          _x = info.x;
          _y = info.y;
          _gazeColor = Colors.green;
        });
      } else {
        setState(() {
          _gazeColor = Colors.red;
        });
      }
    });
    _seesoPlugin.getStatusEvent().listen((event) {
      StatusInfo statusInfo = StatusInfo(event);
      if (statusInfo.type == StatusType.START) {
        setState(() {
          _stateString = "开始跟踪";
          _showingGaze = true;
        });
      } else {
        setState(() {
          _stateString = "停止跟踪 : ${statusInfo.stateErrorType}";
          _showingGaze = false;
        });
      }
    });

    _seesoPlugin.getCalibrationEvent().listen((event) {
      CalibrationInfo caliInfo = CalibrationInfo(event);
      if (caliInfo.type == CalibrationType.CALIBRATION_NEXT_XY) {
        setState(() {
          _nextX = caliInfo.nextX!;
          _nextY = caliInfo.nextY!;
          _calibrationProgress = 0.0;
        });
        Future.delayed(const Duration(milliseconds: 500), () {
          _seesoPlugin.startCollectSamples();
        });
      } else if (caliInfo.type == CalibrationType.CALIBRATION_PROGRESS) {
        setState(() {
          _calibrationProgress = caliInfo.progress!;
        });
      } else if (caliInfo.type == CalibrationType.CALIBRATION_FINISHED) {
        setState(() {
          _isCaliMode = false;
        });
      }
    });
  }

  Future<void> getSeeSoVersion() async {
    String? seesoVersion;
    try {
      seesoVersion = await _seesoPlugin.getSeeSoVersion();
    } on PlatformException {
      seesoVersion = '获取 SeeSo 版本失败';
    }

    if (!mounted) return;

    setState(() {
      _version = seesoVersion!;
    });
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: null, // 隐藏 AppBar
        body: Stack(
          children: [
            if (!_isCaliMode)
              Center(
                child: Column(
                  mainAxisAlignment: MainAxisAlignment.center,
                  children: [
                    Text('SeeSo 版本: $_version'),
                    Text('应用程序有相机权限: $_hasCameraPermissionString'),
                    Text('SeeSo 初始化状态: $_stateString'),
                    const SizedBox(height: 20), // 在文本和按钮之间添加间距
                    if (_isInitialied)
                      ElevatedButton(
                        onPressed: _trackingBtnPressed,
                        child: Text(_trackingBtnText),
                      ),
                    if (_isInitialied && _showingGaze)
                      ElevatedButton(
                          onPressed: _calibrationBtnPressed,
                          child: const Text("开始校准")),
                  ],
                ),
              ),
            if (_showingGaze && !_isCaliMode)
              Positioned(
                left: _x - 5,
                top: _y - 5,
                child: Container(
                  width: 10,
                  height: 10,
                  decoration: BoxDecoration(
                    color: _gazeColor,
                    shape: BoxShape.circle,
                  ),
                ),
              ),
            if (_isCaliMode)
              Positioned(
                left: _nextX - 10,
                top: _nextY - 10,
                child: SizedBox(
                  width: 20,
                  height: 20,
                  child: CircularProgressIndicator(
                    value: _calibrationProgress,
                    backgroundColor: Colors.grey,
                  ),
                ),
              )
          ],
        ),
      ),
    );
  }
}

更多关于Flutter插件seeso_flutter的使用_seeso_flutter是一个用于实时计算用户视线位置的眼动追踪库。所有计算都在设备上本地完成的实战教程也可以访问 https://www.itying.com/category-92-b0.html

eggper 1楼

更多关于Flutter插件seeso_flutter的使用_seeso_flutter是一个用于实时计算用户视线位置的眼动追踪库。所有计算都在设备上本地完成的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html

在Flutter中，尽管seeso_flutter插件的具体功能和用途是未定义的，但基于插件名称“seeso_flutter”进行合理推测，我们可以假设这个插件可能与某种“查看（see）”或“监视（so，可能代表某种观察或监控）”功能相关。在没有官方文档和具体API参考的情况下，以下是一个基于假设的示例代码框架，展示如何在Flutter项目中集成和使用一个假想的seeso_flutter插件。

假设的`seeso_flutter`插件使用示例

添加依赖

首先，我们需要在pubspec.yaml文件中添加对seeso_flutter插件的依赖（注意：这里的依赖是假设的，实际使用时需要替换为真实存在的插件及其版本）。
```
dependencies:
  flutter:
    sdk: flutter
  seeso_flutter: ^0.0.1  # 假设的版本号
```
导入插件

在需要使用seeso_flutter插件的Dart文件中导入它。
```
import 'package:seeso_flutter/seeso_flutter.dart';
```

初始化插件

假设seeso_flutter插件有一个初始化方法，我们可能需要在应用启动时调用它。

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  // 假设有一个初始化方法
  SeesoFlutter.instance.initialize().then((_) {
    runApp(MyApp());
  }).catchError((error) {
    print('Failed to initialize seeso_flutter: $error');
    runApp(ErrorApp());  // 一个处理错误的App示例
  });
}

使用插件功能

基于插件名称推测，我们可能想要使用某种“查看”或“监视”功能。以下是一个假设的示例，展示如何使用一个假想的startMonitoring方法来开始监视某些数据。

class MyApp extends StatefulWidget {
  [@override](/user/override)
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  String monitoringData = 'No data available';

  [@override](/user/override)
  void initState() {
    super.initState();
    // 假设有一个开始监视的方法
    SeesoFlutter.instance.startMonitoring().listen((data) {
      setState(() {
        monitoringData = data;
      });
    }, onError: (error) {
      print('Monitoring error: $error');
    });
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('Seeso Flutter Demo'),
        ),
        body: Center(
          child: Text(monitoringData),
        ),
      ),
    );
  }
}

停止监视（如果适用）

如果插件提供了停止监视的方法，我们应该在应用不需要监视数据时调用它，例如在应用关闭或页面销毁时。
```
[@override](/user/override)
void dispose() {
  // 假设有一个停止监视的方法
  SeesoFlutter.instance.stopMonitoring();
  super.dispose();
}
```

注意

以上代码是基于对seeso_flutter插件名称的合理推测编写的，并非真实存在的插件代码。
实际使用时，必须参考插件的官方文档和API参考，以确保正确集成和使用插件。
如果seeso_flutter插件实际上存在，但功能与我上述推测不符，那么请根据插件的实际功能进行调整。

Flutter插件seeso_flutter的使用_seeso_flutter是一个用于实时计算用户视线位置的眼动追踪库。所有计算都在设备上本地完成