DeviceSelectorAction.java

/*
 * Copyright 2016 The Chromium Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
package io.flutter.actions;

import com.intellij.ide.ActivityTracker;
import com.intellij.openapi.actionSystem.*;
import com.intellij.openapi.actionSystem.ex.ComboBoxAction;
import com.intellij.openapi.application.Application;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.ModalityState;
import com.intellij.openapi.project.DumbAware;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.project.ProjectManager;
import com.intellij.openapi.project.ProjectManagerListener;
import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.SystemInfo;
import com.intellij.ui.JBColor;
import com.intellij.util.ModalityUiUtil;
import icons.FlutterIcons;
import io.flutter.FlutterBundle;
import io.flutter.run.FlutterDevice;
import io.flutter.run.daemon.DeviceService;
import io.flutter.sdk.AndroidEmulatorManager;
import io.flutter.utils.FlutterModuleUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.awt.Component;
import java.util.*;

public class DeviceSelectorAction extends ComboBoxAction implements DumbAware {
  private final List<AnAction> actions = new ArrayList<>();
  private final List<Project> knownProjects = Collections.synchronizedList(new ArrayList<>());

  private @Nullable SelectDeviceAction selectedDeviceAction;

  DeviceSelectorAction() {
    setSmallVariant(true);
  }

  public @NotNull ActionUpdateThread getActionUpdateThread() {
    return ActionUpdateThread.BGT;
  }

  @Override
  public @NotNull JComponent createCustomComponent(@NotNull Presentation presentation, @NotNull String place) {
    final JComponent component = super.createCustomComponent(presentation, place);
    // Set component to be transparent to match other toolbar actions
    component.setOpaque(false);
    // Update child components.
    updateComponentChildrenStyles(component);
    return component;
  }

  private void updateComponentChildrenStyles(@NotNull JComponent parent) {
    final @Nullable Component[] children = parent.getComponents();
    if (children == null) {
      return;
    }

    for (Component child : children) {
      if (child instanceof JComponent jComponent) {
        jComponent.setOpaque(false);

        if (child instanceof JButton jButton) {
          jButton.setBorderPainted(false);
          jButton.setRolloverEnabled(true);
          // Make sure the button uses correct background & foreground.
          jButton.setBackground(JBColor.background());
          jButton.setForeground(JBColor.foreground());
        }

        updateComponentChildrenStyles(jComponent);
      }
    }
  }

  @Override
  protected @NotNull DefaultActionGroup createPopupActionGroup(@NotNull JComponent button, @NotNull DataContext dataContext) {
    final DefaultActionGroup group = new DefaultActionGroup();
    group.addAll(actions);
    return group;
  }

  @Override
  protected boolean shouldShowDisabledActions() {
    return true;
  }

  @Override
  public void update(@NotNull AnActionEvent e) {
    // Only show device menu when the device daemon process is running.
    final Project project = e.getProject();
    if (!isSelectorVisible(project)) {
      e.getPresentation().setVisible(false);
      return;
    }

    super.update(e);

    final Presentation presentation = e.getPresentation();
    if (!knownProjects.contains(project)) {
      knownProjects.add(project);
      final Application application = ApplicationManager.getApplication();
      if (application != null) {
        application.getMessageBus().connect().subscribe(ProjectManager.TOPIC, new ProjectManagerListener() {
          @Override
          public void projectClosed(@NotNull Project closedProject) {
            knownProjects.remove(closedProject);
          }
        });
      }
      Runnable deviceListener = () -> queueUpdate(project, e.getPresentation());
      DeviceService.getInstance(project).addListener(deviceListener);

      // Listen for android device changes, and rebuild the menu if necessary.
      Runnable emulatorListener = () -> queueUpdate(project, e.getPresentation());
      AndroidEmulatorManager.getInstance(project).addListener(emulatorListener);
      var projectManager = ProjectManager.getInstance();
      if (projectManager != null) {
        projectManager.addProjectManagerListener(project, new ProjectManagerListener() {
          public void projectClosing(@NotNull Project project) {
            DeviceService.getInstance(project).removeListener(deviceListener);
            AndroidEmulatorManager.getInstance(project).removeListener(emulatorListener);
          }
        });
      }
      update(project, presentation);
    }

    final DeviceService deviceService = DeviceService.getInstance(project);

    final FlutterDevice selectedDevice = deviceService.getSelectedDevice();
    final Collection<FlutterDevice> devices = deviceService.getConnectedDevices();

    if (devices.isEmpty()) {
      final boolean isLoading = deviceService.getStatus() == DeviceService.State.LOADING;
      if (isLoading) {
        presentation.setText(FlutterBundle.message("devicelist.loading"));
      }
      else {
        presentation.setText("<no devices>");
      }
    }
    else if (selectedDevice == null) {
      presentation.setText("<no device selected>");
    }
    else if (selectedDeviceAction != null) {
      final Presentation template = selectedDeviceAction.getTemplatePresentation();
      presentation.setIcon(template.getIcon());
      presentation.setText(selectedDevice.presentationName());
      presentation.setEnabled(true);
    }
  }

  private void queueUpdate(@NotNull Project project, @NotNull Presentation presentation) {
    ModalityUiUtil.invokeLaterIfNeeded(
      ModalityState.defaultModalityState(),
      () -> update(project, presentation));
  }

  private void update(@NotNull Project project, @NotNull Presentation presentation) {
    if (project.isDisposed()) {
      return; // This check is probably unnecessary, but safe.
    }
    updateActions(project, presentation);
    updateVisibility(project, presentation);
  }

  private static void updateVisibility(final Project project, final @NotNull Presentation presentation) {
    final boolean visible = isSelectorVisible(project);

    final JComponent component = presentation.getClientProperty(new Key<>("customComponent"));
    if (component != null) {
      component.setVisible(visible);
      var parent = component.getParent();
      if (parent != null) {
        parent.doLayout();
        parent.repaint();
      }
    }
  }

  private static boolean isSelectorVisible(@Nullable Project project) {
    if (project == null || !FlutterModuleUtils.hasFlutterModule(project)) {
      return false;
    }
    final DeviceService deviceService = DeviceService.getInstance(project);
    return deviceService.isRefreshInProgress() || deviceService.getStatus() != DeviceService.State.INACTIVE;
  }

  private void updateActions(@NotNull Project project, Presentation presentation) {
    actions.clear();

    final DeviceService deviceService = DeviceService.getInstance(project);

    final FlutterDevice selectedDevice = deviceService.getSelectedDevice();
    final Collection<FlutterDevice> devices = deviceService.getConnectedDevices();

    selectedDeviceAction = null;

    for (FlutterDevice device : devices) {
      if (device == null) continue;

      final SelectDeviceAction deviceAction = new SelectDeviceAction(device, devices);
      actions.add(deviceAction);

      if (Objects.equals(device, selectedDevice)) {
        selectedDeviceAction = deviceAction;

        final Presentation template = deviceAction.getTemplatePresentation();
        //noinspection DataFlowIssue
        presentation.setIcon(template.getIcon());
        //presentation.setText(deviceAction.presentationName());
        presentation.setEnabled(true);
      }
    }

    // Show the 'Open iOS Simulator' action.
    if (SystemInfo.isMac) {
      boolean simulatorOpen = false;
      for (AnAction action : actions) {
        if (action instanceof SelectDeviceAction deviceAction) {
          final FlutterDevice device = deviceAction.device;
          if (device.isIOS() && device.emulator()) {
            simulatorOpen = true;
          }
        }
      }

      actions.add(new Separator());
      actions.add(new OpenSimulatorAction(!simulatorOpen));
    }

    // Add Open Android emulators actions.
    final List<OpenEmulatorAction> emulatorActions = OpenEmulatorAction.getEmulatorActions(project);
    if (emulatorActions != null && !emulatorActions.isEmpty()) {
      actions.add(new Separator());
      actions.addAll(emulatorActions);
    }
    if (!FlutterModuleUtils.hasInternalDartSdkPath(project)) {
      actions.add(new Separator());
      actions.add(RestartFlutterDaemonAction.forDeviceSelector());
    }

    var tracker = ActivityTracker.getInstance();
    if (tracker != null) {
      tracker.inc();
    }
  }

  // Show the current device as selected when the combo box menu opens.
  @Override
  protected Condition<AnAction> getPreselectCondition() {
    return action -> action == selectedDeviceAction;
  }

  private static class SelectDeviceAction extends AnAction {
    @NotNull
    private final FlutterDevice device;

    SelectDeviceAction(@NotNull FlutterDevice device, @NotNull Collection<FlutterDevice> devices) {
      super(device.getUniqueName(devices), null, FlutterIcons.Phone);
      this.device = device;
    }

    public @NotNull String presentationName() {
      return device.presentationName();
    }

    @Override
    public void actionPerformed(@NotNull AnActionEvent e) {
      final Project project = e.getProject();
      final DeviceService service = project == null ? null : DeviceService.getInstance(project);
      if (service != null) {
        service.setSelectedDevice(device);
      }
    }

    @Override
    public @NotNull ActionUpdateThread getActionUpdateThread() {
      return ActionUpdateThread.BGT;
    }
  }
}