You can modify the WebSocketLink class to handle application inactivity by adding methods to subscribe and unsubscribe when the application's state changes. You'll need to listen for application state changes and call these methods accordingly.

Here's an example of how you can achieve this:

Modify the WebSocketLink class to add two new methods: subscribeOnActive and unsubscribeOnInactive.
dart
Copy code
class WebSocketLink extends Link {
  // ...

  // Add this method to the WebSocketLink class
  void subscribeOnActive() {
    if (_connectionIsInactive) {
      _connectionIsInactive = false;
      _handleInitOperation();
    }
  }

  // Add this method to the WebSocketLink class
  void unsubscribeOnInactive() {
    if (!_connectionIsInactive) {
      _connectionIsInactive = true;
      _terminate();
    }
  }
}
Add a _connectionIsInactive field to the WebSocketLink class, which will be used to track the connection state.
dart
Copy code
class WebSocketLink extends Link {
  // ...

  bool _connectionIsInactive = false;

  // ...
}
Listen for application state changes in your application. Use the WidgetsBindingObserver mixin along with the didChangeAppLifecycleState method to detect when the application becomes inactive or active. When the state changes, call the subscribeOnActive or unsubscribeOnInactive methods on your WebSocketLink instance.
Here's an example in a Flutter app:

dart
Copy code
import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
import 'package:gql_websocket_link/gql_websocket_link.dart';

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

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> with WidgetsBindingObserver {
  WebSocketLink _webSocketLink;

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    _webSocketLink = WebSocketLink("your-websocket-url");
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    _webSocketLink.unsubscribeOnInactive();
    super.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.resumed) {
      _webSocketLink.subscribeOnActive();
    } else if (state == AppLifecycleState.inactive ||
        state == AppLifecycleState.paused ||
        state == AppLifecycleState.detached) {
      _webSocketLink.unsubscribeOnInactive();
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('WebSocketLink Example'),
      ),
      body: Center(
        child: Text('Subscribe/Unsubscribe based on app state'),
      ),
    );
  }
}
In this example, the MyHomePage state listens for changes to the application's lifecycle state. When the application becomes active (resumed), it calls the subscribeOnActive method to reconnect to the WebSocket and initiate the connection. When the application becomes inactive, paused, or detached, it calls the unsubscribeOnInactive method to terminate the connection.

This way, you can manage the connection based on your application's state and optimize resources when the application is not active.