Integrate Meeting Place for Dart

        
// create a Persistent wallet using SSI
final wallet = PersistentWallet(InMemoryKeyStore());

// create a RepositoryConfig
final storage = InMemoryStorage();
final repositoryConfig = RepositoryConfig(
    connectionOfferRepository: ConnectionOfferRepositoryImpl(storage: storage),
    groupRepository: GroupRepositoryImpl(storage: storage),
    channelRepository: ChannelRepositoryImpl(storage: storage),
    keyRepository: KeyRepositoryImpl(storage: storage),
);

// Define the mediator did
final mediatorDid = '<YOUR-MEDIATOR-DID>:.well-known';

// Define the serviceDID (control plane DID)
final serviceDid = '<YOUR-CONTROL-PLANE-DID>';

// Create an instance of Core SDK
final aliceSDK = await CoreSDK.create(
    wallet: wallet,
    repositoryConfig: repositoryConfig,
    mediatorDid: mediatorDid,
    serviceDid: serviceDid
);

// Register the device to receive push notification
await aliceSDK.registerForPushNotifications(const Uuid().v4());

        

// Publish an offer using Core SDK
final publishOfferResult = await aliceSDK.publishOffer(
    offerName: '<YOUR-OFFER-NAME>',
    offerDescription: '<YOUR-OFFER-DESC>',
    customPhrase: '<YOUR-CUSTOM-PHRASE>', // if not provided, it will generate a random mnemonic
    vCard: VCard(values: {}),
    publishAsGroup: false,
    validUntil: DateTime.now().toUtc().add(const Duration(minutes: 5)),
);

// Listen to Discovery Events Stream to receive updates about the published offer
final waitForInvitationAccept = Completer<DiscoveryStreamEvent>();
final waitForChannelActivity = Completer<DiscoveryStreamEvent>();

aliceSDK.discoveryEventsStream.listen((event) {
    if (event.type == DiscoveryEventType.InvitationAccept) {
        waitForInvitationAccept.complete(event);
    }

    if (event.type == DiscoveryEventType.ChannelActivity) {
        if (!waitForChannelActivity.isCompleted) {
            waitForChannelActivity.complete(event);
        }
    }
});

// Create a Mediator Channel to listen to discovery events about the published offer
final publishOfferMediatorChannel = await aliceSDK.subscribeToMediator(
    publishOfferResult.connectionOffer.publishOfferDid,
    deleteOnMediator: false,
);

// Use the Mediator Channel to listen to discovery events about the published offer
publishOfferMediatorChannel.stream.listen((data) async {
    if (data.type.toString() == MeetingPlaceProtocol.connectionSetup.value) {
      await aliceSDK.processDiscoveryEvents();
    }
});

        

// Find the offer using Alice's mnemonic
final findOfferResult = await bobSDK.findOffer(mnemonic: '<ALICE-OFFER>');

        

// Accept the offer to accept the invite
final acceptOfferResult = await bobSDK.acceptOffer(
    connectionOffer: findOfferResult.connectionOffer!,
    vCard: VCard(values: {}),
);

// Listen on discovery events stream to receive update on the accepted offer
final waitForOfferFinalised = Completer<DiscoveryStreamEvent>();
bobSDK.discoveryEventsStream.listen((event) {
    if (event.type == DiscoveryEventType.OfferFinalised) {
      waitForOfferFinalised.complete(event);
    }
});

// Create a Mediator Channel to listen to discovery events about the accepted offer
final mediatorChannel = await bobSDK.subscribeToMediator(
    acceptOfferResult.connectionOffer.acceptOfferDid!,
    deleteOnMediator: false,
);

// Use the Mediator Channel to listen to discovery events about the accepted offer
mediatorChannel.stream.listen((data) async {
    if (data.type.toString() == MeetingPlaceProtocol.connectionAccepted.value) {
      await Future.delayed(Duration(seconds: 3));
      await bobSDK.processDiscoveryEvents();
    }
});

// Send a notification to Alice that Bob had requested to connect
await bobSDK.notifyAcceptance(
    connectionOffer: acceptOfferResult.connectionOffer);

        

// Get the connection request event from Bob
final receivedEvent = await waitForInvitationAccept.future;

// Alice approves/accepts the connection request from Bob
final channel = await aliceSDK.approveConnectionRequest(
    connectionOffer: publishOfferResult.connectionOffer,
    channel: receivedEvent.channel,
);

// Setup the permanent channel
final permanentChannelDidMediatorChannel = await aliceSDK.subscribeToMediator(
    channel.permanentChannelDid!,
    deleteOnMediator: false,
);

// Listen to discovery events about channel inauguration from Bob
permanentChannelDidMediatorChannel.stream.listen((data) async {
    if (data.type.toString() == MeetingPlaceProtocol.channelInauguration.value) {
      await aliceSDK.processDiscoveryEvents();
    }
});

        

// Create an instance of ChatSDK
final aliceChatSDK = await ChatSDK.initialiseFromChannel(
    channel,
    coreSDK: aliceSDK,
    chatRepository: ChatRepositoryImpl(storage: InMemoryStorage()),
    options: ChatSDKOptions(chatPresenceSendInterval: 60),
);

// Start the chat session using the created ChatSDK
await aliceChatSDK.start();

// Setup the channel stream to get message events from the chat
await aliceChatSDK.channelSubscription.then((stream) {
    stream!.listen((data) {
      if (data.plainTextMessage != null) {
        prettyJsonPrintYellow(
          'Received message on chat stream',
          data.plainTextMessage!.toJson(),
        );
      }

      if (data.chatItem != null) {
        prettyJsonPrintYellow(
          'Received chat item on chat stream',
          data.chatItem!.toJson(),
        );
      }
    });
  });

        

// Send a plain text message to Alice
await bobChatSDK.sendTextMessage('Hi Alice!');

        

final bobSDK = await CoreSDK.create(...);

await bobSDK.sendMessage(
    PlainTextMessage(
      id: Uuid().v4(),
      type: Uri.parse(ChatProtocol.chatMessage.value),
      from: offerFinalisedEvent.channel.permanentChannelDid,
      to: [offerFinalisedEvent.channel.otherPartyPermanentChannelDid!],
      body: {'text': 'This is a custom message', 'seqNo': 100},
    ),
    senderDid: offerFinalisedEvent.channel.permanentChannelDid!,
    recipientDid: offerFinalisedEvent.channel.otherPartyPermanentChannelDid!,
);