import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
public CompletableFuture<MessageActionItem> sendShowMessageRequest(
    ShowMessageRequestParams requestParams) {
  CompletableFuture<MessageActionItem> result = new CompletableFuture<>();
  if (showMessageRequestEndpointIds.isEmpty()) {
    result.complete(null);
  }
  for (String endpointId : endpointIds) {
    requestTransmitter
        .newRequest()
        .endpointId(endpointId)
        .methodName("window/showMessageRequest")
        .paramsAsDto(requestParams)
        .sendAndReceiveResultAsDto(MessageActionItem.class)
        .onSuccess(
            actionItem -> {
              if (!result.isDone()) {
                result.complete(actionItem);
              }
            })
        .onFailure(
            jsonRpcError ->
                result.completeExceptionally(new Exception(jsonRpcError.getMessage())));
  }

  return result;
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
@Test
public void testName() throws Exception {
  CompletableFuture<MessageActionItem> future = new CompletableFuture<>();
  when(transmitter.sendShowMessageRequest(any())).thenReturn(future);

  ServerInitializerImpl initializer = new ServerInitializerImpl();
  CheLanguageClient client = new CheLanguageClient(eventService, transmitter, "id");
  CompletableFuture<Pair<LanguageServer, InitializeResult>> initialize =
      initializer.initialize(launcher, client, "/tmp");
  Pair<LanguageServer, InitializeResult> resultPair = initialize.get();
  server = resultPair.first;
  ArgumentCaptor<ShowMessageRequestParams> captor =
      ArgumentCaptor.forClass(ShowMessageRequestParams.class);
  verify(transmitter, timeout(1500)).sendShowMessageRequest(captor.capture());

  ShowMessageRequestParams value = captor.getValue();
  assertNotNull(value);
  assertEquals(value.getType(), MessageType.Error);
  assertEquals(value.getMessage(), "Error Message!!!!");
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
public JsonRpcPromise<MessageActionItem> processNotificationRequest(
    ShowMessageRequestParams params) {
  JsonRpcPromise<MessageActionItem> result = new JsonRpcPromise<>();

  MessageDialogPresenter dialogPresenter = provider.get();
  dialogPresenter.show(
      params.getMessage(),
      params.getType().toString(),
      params.getActions(),
      actionItem -> {
        result
            .getSuccessConsumer()
            .ifPresent(consumer -> consumer.accept("ws-agent", actionItem));
      });

  return result;
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
@Inject
private void configureShowMessageRequestReceiver(
    Provider<ShowMessageRequestProcessor> provider, RequestHandlerConfigurator configurator) {
  configurator
      .newConfiguration()
      .methodName("window/showMessageRequest")
      .paramsAsDto(ShowMessageRequestParams.class)
      .resultAsPromiseDto(MessageActionItem.class)
      .withPromise(params -> provider.get().processNotificationRequest(params));
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
public void show(
    String content,
    String title,
    List<MessageActionItem> actions,
    Consumer<MessageActionItem> callback) {
  this.callback = callback;
  view.setContent(content);
  view.setTitle(title);
  view.setActions(actions);
  view.showDialog();
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
public void setActions(List<MessageActionItem> actions) {
  actions.forEach(
      action -> {
        Button button = new Button();
        button.setText(action.getTitle());
        button.addClickHandler(clickEvent -> actionDelegate.onAction(action));
        button.addStyleName(style.actionButton());
        rootPanel.add(button);
      });
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
@Override
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams) {
	return null;
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
public ShowMessageRequestParams(final List<MessageActionItem> actions) {
  this.actions = actions;
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
/**
 * The message action items to present.
 */
@Pure
public List<MessageActionItem> getActions() {
  return this.actions;
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
/**
 * The message action items to present.
 */
public void setActions(final List<MessageActionItem> actions) {
  this.actions = actions;
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
public CompletableFuture<MessageActionItem> showMessageRequest(final ShowMessageRequestParams requestParams) {
  return this.noImpl3.showMessageRequest(requestParams);
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
@Override
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams) {
	throw new UnsupportedOperationException();
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
@Override
public CompletableFuture<MessageActionItem> showMessageRequest(
    ShowMessageRequestParams requestParams) {
  return transmitter.sendShowMessageRequest(requestParams);
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
@Override
public void onAction(MessageActionItem actionItem) {
  view.closeDialog();
  callback.accept(actionItem);
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
@Override
public void setActions(List<MessageActionItem> actions) {
  footer.setActions(actions);
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
/**
 * Sends the message to the client, to be displayed on a UI element.
 * Waits for an answer from the user and returns the selected
 * action.
 *
 * @param type
 * @param msg
 * @return
 */
public MessageActionItem showNotificationMessageRequest(MessageType type, String msg, List<MessageActionItem> actions){
	ShowMessageRequestParams $ = new ShowMessageRequestParams();
	$.setMessage(msg);
	$.setType(type);
	$.setActions(actions);
	return client.showMessageRequest($).join();
}
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
/**
 * The show message request is sent from a server to a client to ask the
 * client to display a particular message in the user interface. In addition
 * to the show message notification the request allows to pass actions and
 * to wait for an answer from the client.
 */
@JsonRequest("window/showMessageRequest")
CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams);
 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
void setActions(List<MessageActionItem> actions); 

import org.eclipse.lsp4j.MessageActionItem; //导入依赖的package包/类
void onAction(MessageActionItem actionItem);