mixin GameTimerDelegate {
  void gameOver();
}

class GameBoard extends StatefulWidget with GameTimerDelegate {
  // ... 생략

  void gameOver() {
    print("game over");
  }
}

class GameTimer extends StatefulWidget {
  GameTimerDelegate delegate; // 델리게이트 선언

  @override
  _GameTimerState createState() => _GameTimerState();
}

class _GameTimerState extends State<GameTimer> {
  // ... 생략

  void startTimer() {
    // ... 타이머 로직 생략

    if (remainingTime < 1) {
      timer.cancel();
      widget.delegate.gameOver(); // 델리게이트를 통해 함수 호출
    } else {
      remainingTime = remainingTime - 1;
    }
  }
}

import 'gameBoard.dart';
import 'gameTimer.dart';

class Game extends StatefulWidget {
  @override
  _GameState createState() => _GameState();
}

class _GameState extends State<Game> {
  @override
  Widget build(BuildContext context) {
    final gameBoard = GameBoard();
    final gameTimer = GameTimer();
    gameTimer.delegate = gameBoard; // 객체 연결하기
    return Scaffold(body: gameBoard, floatingActionButton: gameTimer);
  }
}

class FirebaseFirestore extends FirebasePluginPlatform {
  FirebaseFirestorePlatform _delegatePackingProperty;

  FirebaseFirestorePlatform /*!*/ get _delegate {
    if (_delegatePackingProperty == null) {
      _delegatePackingProperty =
          FirebaseFirestorePlatform.instanceFor(app: app);
    }
    return _delegatePackingProperty;
  }
...

}

/// Defines an interface to work with Cloud Firestore on web and mobile
abstract class FirebaseFirestorePlatform extends PlatformInterface {
  ...

  /// The current default [FirebaseFirestorePlatform] instance.
  ///
  /// It will always default to [MethodChannelFirebaseFirestore]
  /// if no other implementation was provided.
  static FirebaseFirestorePlatform get instance {
    if (_instance == null) {
      _instance = MethodChannelFirebaseFirestore(app: Firebase.app());
    }
    return _instance;
  }
	...
  /// Creates a write batch, used for performing multiple writes as a single
  /// atomic operation.
  ///
  /// Unlike transactions, write batches are persisted offline and therefore are
  /// preferable when you don’t need to condition your writes on read data.
  WriteBatchPlatform batch() {
    throw UnimplementedError('batch() is not implemented');
  }

  /// Clears any persisted data for the current instance.
  Future<void> clearPersistence() {
    throw UnimplementedError('clearPersistence() is not implemented');
  }

  /// Enable persistence of Firestore data. Web only.
  Future<void> enablePersistence(
      [PersistenceSettings /*!*/ persistenceSettings]) async {
    throw UnimplementedError('enablePersistence() is not implemented');
  }

  /// Gets a [CollectionReferencePlatform] for the specified Firestore path.
  CollectionReferencePlatform collection(String /*!*/ collectionPath) {
    throw UnimplementedError('collection() is not implemented');
  }
	...
}

/// The entry point for accessing a Firestore.
///
/// You can get an instance by calling [FirebaseFirestore.instance].
class MethodChannelFirebaseFirestore extends FirebaseFirestorePlatform {

  ...

  @override
  CollectionReferencePlatform collection(String path) {
    return MethodChannelCollectionReference(this, path);
  }

  @override
  QueryPlatform collectionGroup(String path) {
    return MethodChannelQuery(this, path, isCollectionGroupQuery: true);
  }

...

}