Flutter Integration

# pubspec.yaml
dependencies:
  nxtchart:
    git:
      url: <neocharts-sdk-repository-url>  # the neocharts-sdk repo you were given access to
      ref: <version-tag>

flutter pub get

flutter:
  assets:
    - neocharts-key.json

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

import 'package:nxtchart/interface.dart';

class MyChartController implements ChartInterface {
  // One broadcast controller per stream, created once per instance -- see
  // "Must be broadcast streams" below. Push JSON with e.g. _orders.add(json).
  final _ticks = StreamController<String>.broadcast();
  final _orders = StreamController<String>.broadcast();
  final _ocoOrders = StreamController<String>.broadcast();
  final _positions = StreamController<String>.broadcast();
  final _alerts = StreamController<String>.broadcast();
  final _actionFeedback = StreamController<String>.broadcast();

  @override
  String get storageKey => 'user_123'; // stable, user-scoped key

  @override
  String get symbolInfo => jsonEncode({
    'id': 'RELIANCE',
    'name': 'Reliance Industries',
    'lotSize': 1,
    'precision': 2,
    'tickSize': 0.05,
    'exchange': 'NSE',
    'expiry': '', // e.g. '2025-03-27' for a derivative; empty for this equity
    'strike': '', // e.g. '23000' for an option; empty for this equity
    'optType': '', // e.g. 'CE' or 'PE' for an option; empty for this equity
    'weekly': '', // e.g. 'Y' marks a weekly expiry; empty for this equity
    'undID': '', // e.g. 'NIFTY' for a derivative; empty for this equity
  });

  @override
  String? get underlyingSymbolInfo => ''; // empty: this equity is the underlying

  @override
  String get optionSymbols => '[]';

  @override
  String? get futureSymbols => null;

  @override
  String? get indexSymbols => null;

  @override
  Future<String?> get atmSymbols async => null;

  @override
  String get marketTimings => jsonEncode({
    // Keyed by exchange code -- add one entry per exchange any symbol
    // reachable this session might resolve to (e.g. also 'NFO' once
    // options are in play). A missing exchange throws; see the
    // marketTimings reference doc.
    'NSE': {
      'timezone': 'Asia/Kolkata',
      'sessions': [
        ['0915-1530'], // Monday
        ['0915-1530'], // Tuesday
        ['0915-1530'], // Wednesday
        ['0915-1530'], // Thursday
        ['0915-1530'], // Friday
        <String>[], // Saturday
        <String>[], // Sunday
      ],
      'holidays': <String>[],
      'special': <String, dynamic>{},
    },
  });

  @override
  Future<String> get chartTopOptions async {
    // JSON list of top options ranked by volume. Entries are keyed by
    // `symId`, not `id` -- see the chartTopOptions reference doc.
    return yourApi.fetchTopOptions();
  }

  @override
  Future<String> loadData({
    required String symbolId,
    required int from, // epoch milliseconds
    required int to, // epoch milliseconds
    required int intervalSeconds,
    required int requiredBars,
  }) async {
    final bars = await yourApi.fetchOHLCV(
      symbolId: symbolId,
      from: from,
      to: to,
      interval: intervalSeconds,
    );
    return jsonEncode(bars); // [[timeMs, open, high, low, close, volume], ...]
  }

  @override
  Stream<String> marketDataStreamer(String symbols) {
    // Called again with the complete new list every time the subscribed set
    // changes. Resubscribe your feed to exactly these ids and return a stream
    // that can be listened to again.
    yourTickFeed.subscribe(List<String>.from(jsonDecode(symbols) as List));
    return _ticks.stream;
  }

  @override
  Stream<String> searchSymbolsStreamer(String query) {
    return yourApi.searchSymbols(query).asStream().map(jsonEncode);
  }

  @override
  // Called when the user picks a symbol in symbol search, taps an option-chain
  // row, or swaps CE/PE or Spot/Fut. Return a new ChartInterface for
  // symbolJson to enable those; returning null makes those taps do nothing.
  // The SDK never disposes the instances you return -- you own them.
  ChartInterface? chartInterfaceForSymbol(String symbolJson) => null;

  @override
  bool get hasOCO => true;

  @override
  bool get isMarketOrderSupported => true;

  @override
  void placeOrder(String params) {
    yourBroker.placeOrder(jsonDecode(params));
  }

  @override
  void modifyOrder(String params) => yourBroker.modifyOrder(jsonDecode(params));

  @override
  void cancelOrder(String orderID) => yourBroker.cancelOrder(orderID);

  @override
  void placeOCOOrder(String params) =>
      yourBroker.placeOCOOrder(jsonDecode(params));

  @override
  void modifyOCOOrder(String params) =>
      yourBroker.modifyOCOOrder(jsonDecode(params));

  @override
  void cancelOCOOrder(String groupId) => yourBroker.cancelOCOOrder(groupId);

  @override
  void groupAdjustOrders(String params) =>
      yourBroker.groupAdjustOrders(jsonDecode(params));

  @override
  Stream<String> get ordersStreamer => _orders.stream;

  @override
  Stream<String> get positionsStreamer => _positions.stream;

  @override
  Future<String> get fundsData => yourApi.fetchFundsData();

  @override
  Stream<String> get actionFeedbackStreamer => _actionFeedback.stream;

  @override
  Stream<String> get ocoOrdersStreamer => _ocoOrders.stream;

  @override
  Future<String> fetchOptionDetails({required String underlyingSymbolId}) =>
      yourApi.fetchOptionChain(underlyingSymbolId);

  @override
  Future<String?> fetchOIAnalysis({
    required String underlyingSymbolId,
    required String expiry,
    required int timeFrom,
    required int timeTo,
  }) =>
      yourApi.fetchOIAnalysis(underlyingSymbolId, expiry, timeFrom, timeTo);

  @override
  Future<String?> fetchOIChange({
    required String underlyingSymbolId,
    required List<String> expiries,
    required int timeFrom,
    required int timeTo,
  }) =>
      yourApi.fetchOIChange(underlyingSymbolId, expiries, timeFrom, timeTo);

  @override
  Future<String?> fetchOI({
    required String underlyingSymbolId,
    required List<String> expiries,
  }) =>
      yourApi.fetchOI(underlyingSymbolId, expiries);

  @override
  Future<String> fetchPcrIntraday() => yourApi.fetchPcrIntraday();

  @override
  Future<String> fetchAtmStraddleIntraday() =>
      yourApi.fetchAtmStraddleIntraday();

  @override
  Future<String> fetchAtmIvIntraday() => yourApi.fetchAtmIvIntraday();

  // Parameterized replacements (xxxFor) -- scoped to an explicit id instead
  // of "whatever's currently charted." underlyingSymbolInfoFor runs on every
  // chart load and chartTopOptionsFor backs the Top 5 panel. The rest aren't
  // called by NxtChartPage yet, but return real data rather than throwing --
  // see /docs/trading/chart-data and /docs/trading/option-chain.
  @override
  Future<String?> underlyingSymbolInfoFor(String symbolId) =>
      yourApi.fetchUnderlyingSymbolInfo(symbolId);

  @override
  Future<String> optionSymbolsFor(String underlyingId) =>
      yourApi.fetchOptionSymbols(underlyingId);

  @override
  Future<String?> futureSymbolsFor(String underlyingId) =>
      yourApi.fetchFutureSymbols(underlyingId);

  @override
  Future<String?> atmSymbolsFor(String underlyingId) =>
      yourApi.fetchAtmSymbols(underlyingId);

  @override
  Future<String> chartTopOptionsFor(String underlyingId) =>
      yourApi.fetchTopOptions(underlyingId);

  @override
  Future<String> fetchPcrIntradayFor(String underlyingId) =>
      yourApi.fetchPcrIntraday(underlyingId);

  @override
  Future<String> fetchAtmStraddleIntradayFor(String underlyingId) =>
      yourApi.fetchAtmStraddleIntraday(underlyingId);

  @override
  Future<String> fetchAtmIvIntradayFor(String underlyingId) =>
      yourApi.fetchAtmIvIntraday(underlyingId);

  @override
  void modifyAlert(String params) => yourBroker.modifyAlert(jsonDecode(params));

  @override
  void createAlert(String params) => yourBroker.createAlert(jsonDecode(params));

  @override
  void deleteAlert(String alertId) => yourBroker.deleteAlert(alertId);

  @override
  Stream<String> get alertsStreamer => _alerts.stream;

  @override
  // Only called when NxtChartPage has no host Navigator above it. A Flutter
  // app that pushes the page as a route (step 4) can leave this empty.
  void closeRequested() {}

  @override
  // Called by NxtChartPage itself when it's removed -- don't call it yourself.
  void dispose() {
    yourTickFeed.unsubscribeAll();
    for (final c in [
      _ticks,
      _orders,
      _ocoOrders,
      _positions,
      _alerts,
      _actionFeedback,
    ]) {
      c.close();
    }
  }
}

import 'package:nxtchart/widgets.dart';

void openChart(BuildContext context) {
  // A fresh controller per open -- NxtChartPage disposes it when it closes.
  final controller = MyChartController();
  // Root navigator: the chart's close button pops the root Navigator.
  Navigator.of(context, rootNavigator: true).push(
    MaterialPageRoute<void>(
      builder: (_) => NxtChartPage(dataProvider: controller),
    ),
  );
}

<activity
    android:name=".MainActivity"
    android:enableOnBackInvokedCallback="false"
    ... >

@override
Future<String?> get atmSymbols async => jsonEncode([
  {'id': 'NIFTY24DEC24000CE', 'name': 'NIFTY 24000 CE', 'optType': 'CE',
   'strike': '24000', 'expiry': '2024-12-26', 'exchange': 'NFO', 'undID': 'NIFTY'},
  {'id': 'NIFTY24DEC24000PE', 'name': 'NIFTY 24000 PE', 'optType': 'PE',
   'strike': '24000', 'expiry': '2024-12-26', 'exchange': 'NFO', 'undID': 'NIFTY'},
]);

final _actionFeedback = StreamController<String>.broadcast();

@override
Stream<String> get actionFeedbackStreamer => _actionFeedback.stream;

@override
Future<String> loadData({...}) async {
  final bars = await yourApi.fetchOHLCV(...); // must await
  return jsonEncode(bars);
}