Skip to main content

terra_flutter_bridge 2.3.0 copy "terra_flutter_bridge: ^2.3.0" to clipboard
terra_flutter_bridge: ^2.3.0 copied to clipboard

Terra's health SDK for Flutter, over the same generated bridge as the React Native package.

example/lib/main.dart

import 'dart:async';
import 'dart:convert';
import 'dart:io';

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

/// Where the token provider asks for a connect token: your backend, which calls Terra's
/// `POST /v2/auth/generateAuthToken` with your API key and answers `{"token": "..."}`.
const String tokenUrl = String.fromEnvironment('TERRA_TOKEN_URL');

/// The person this install links, as your backend names them.
const String referenceId = String.fromEnvironment('TERRA_REFERENCE_ID',
    defaultValue: 'terra-flutter-example');

const List<DataCategory> categories = <DataCategory>[
  DataCategory.activity,
  DataCategory.daily,
  DataCategory.sleep,
];

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  runApp(ExampleApp(terra: createTerra(tokenProvider: fetchToken)));
}

/// Fetches a connect token from [tokenUrl]. Only asked when a connect needs a new link.
Future<String> fetchToken() async {
  if (tokenUrl.isEmpty) {
    throw StateError(
        'no token server: run with --dart-define=TERRA_TOKEN_URL=...');
  }
  final client = HttpClient();
  try {
    final response = await (await client.postUrl(Uri.parse(tokenUrl))).close();
    final body = await response.transform(utf8.decoder).join();
    final token = (jsonDecode(body) as Map<String, Object?>)['token'];
    if (response.statusCode != 200 || token is! String) {
      throw StateError('the token server answered ${response.statusCode}');
    }
    return token;
  } finally {
    client.close();
  }
}

class ExampleApp extends StatelessWidget {
  const ExampleApp({super.key, required this.terra});

  final Terra terra;

  @override
  Widget build(BuildContext context) => MaterialApp(
        title: 'Terra Flutter Example',
        theme: ThemeData(colorSchemeSeed: Colors.indigo, useMaterial3: true),
        home: HomePage(terra: terra),
      );
}

class HomePage extends StatefulWidget {
  const HomePage({super.key, required this.terra});

  final Terra terra;

  @override
  State<HomePage> createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  Terra get terra => widget.terra;

  final List<String> _log = <String>[];
  StreamSubscription<TerraEvent>? _events;
  bool _busy = false;

  @override
  void dispose() {
    unawaited(_events?.cancel());
    super.dispose();
  }

  void _say(String line) => setState(() => _log.insert(0, line));

  Future<void> _run(String name, Future<String> Function() action) async {
    setState(() => _busy = true);
    try {
      _say('$name: ${await action()}');
    } on TerraError catch (error) {
      _say('$name failed: ${error.code.wire} (${error.message})');
    } catch (error) {
      _say('$name failed: $error');
    } finally {
      if (mounted) setState(() => _busy = false);
    }
  }

  Future<String> _status() async {
    final state = await terra.attach();
    final availability = await terra.availability();
    return 'bootstrapped=${state.bootstrapped} platform=${state.platform} '
        'sdk=${state.sdkVersion} store=$availability';
  }

  Future<String> _permissions() async {
    final granted = await terra.permissions.request(read: categories);
    return granted == null
        ? 'asked (this platform does not say what was granted)'
        : 'read=${granted.read.map((c) => c.wire).join(',')}';
  }

  Future<String> _connect() async {
    final connection = await terra.connect(
        Source.health, const EndUser.reference(id: referenceId));
    return 'linked ${connection.source.wire} as ${connection.userId}';
  }

  Future<String> _sync() async {
    final state = await terra.diagnostics.state();
    final last = await terra.diagnostics.lastDelivery();
    return '${state.runtimeType}, last delivery ${last?.toLocal() ?? 'never'}';
  }

  Future<String> _read() async {
    const range = TimeRange.lastDays(days: 7);
    final steps = await terra.daily.steps(range);
    final workouts = await terra.activity.workouts(range);
    final sleep = await terra.sleep.segments(range);
    return '${steps.length} step counts, ${workouts.length} workouts, '
        '${sleep.length} sleep segments in 7 days';
  }

  Future<String> _toggleEvents() async {
    final open = _events;
    if (open != null) {
      _events = null;
      await open.cancel();
      return 'stopped';
    }
    _events = terra.diagnostics.events().listen(
          (event) => _say('event: ${event['event']}'),
          onError: (Object error) => _say(
              'events failed: ${error is TerraError ? error.code.wire : error}'),
          onDone: () => _events = null,
        );
    return 'listening';
  }

  Future<String> _disconnect() async {
    await terra.disconnect(source: Source.health);
    return 'unlinked';
  }

  @override
  Widget build(BuildContext context) {
    final actions = <(String, Future<String> Function())>[
      ('Status', _status),
      ('Permissions', _permissions),
      ('Connect', _connect),
      ('Sync', _sync),
      ('Read', _read),
      (_events == null ? 'Events' : 'Stop events', _toggleEvents),
      ('Disconnect', _disconnect),
    ];
    return Scaffold(
      appBar: AppBar(title: const Text('Terra Flutter Example')),
      body: SafeArea(
        child: CustomScrollView(
          slivers: <Widget>[
            SliverPadding(
              padding: const EdgeInsets.all(16),
              sliver: SliverToBoxAdapter(
                child: Wrap(
                  spacing: 8,
                  runSpacing: 8,
                  children: <Widget>[
                    for (final (label, action) in actions)
                      FilledButton.tonal(
                        key: ValueKey<String>(label),
                        onPressed: _busy ? null : () => _run(label, action),
                        child: Text(label),
                      ),
                  ],
                ),
              ),
            ),
            const SliverToBoxAdapter(child: Divider(height: 1)),
            if (_log.isEmpty)
              SliverFillRemaining(
                hasScrollBody: false,
                child: Center(
                  child: Padding(
                    padding: const EdgeInsets.all(16),
                    child: Text(
                      'Tap an action to call the SDK',
                      textAlign: TextAlign.center,
                      style: Theme.of(context).textTheme.bodyMedium,
                    ),
                  ),
                ),
              )
            else
              SliverPadding(
                padding: const EdgeInsets.all(16),
                sliver: SliverList.separated(
                  itemCount: _log.length,
                  separatorBuilder: (context, index) =>
                      const SizedBox(height: 8),
                  itemBuilder: (context, index) => Text(
                    _log[index],
                    key: ValueKey<int>(_log.length - index),
                    style: Theme.of(context).textTheme.bodySmall,
                  ),
                ),
              ),
          ],
        ),
      ),
    );
  }
}
9
likes
145
points
2.89k
downloads

Documentation

API reference

Publisher

verified publishertryterra.co

Weekly Downloads

Terra's health SDK for Flutter, over the same generated bridge as the React Native package.

Homepage
Repository (GitHub)

License

MIT (license)

Dependencies

flutter

More

Packages that depend on terra_flutter_bridge

Packages that implement terra_flutter_bridge