Target Management

/**
 * v133-specific target management implementation
 * Implements org.openqa.selenium.devtools.idealized.target.Target for browser target operations
 */
public class v133Target implements org.openqa.selenium.devtools.idealized.target.Target {
    /**
     * Creates a new v133Target instance
     * Uses default constructor - no parameters required as operations are static
     */
}

/**
 * Get list of all available targets (tabs, pages, workers, etc.)
 * @return Command returning list of TargetInfo objects
 */
public Command<List<org.openqa.selenium.devtools.idealized.target.model.TargetInfo>> getTargets();

import org.openqa.selenium.devtools.v133.v133Target;
import org.openqa.selenium.devtools.idealized.target.model.TargetInfo;
import java.util.List;

v133Target target = new v133Target();

// Get all available targets
List<TargetInfo> targets = devTools.send(target.getTargets());

for (TargetInfo targetInfo : targets) {
    System.out.printf("Target: %s (%s) - %s%n",
        targetInfo.getTitle(),
        targetInfo.getType(),
        targetInfo.getUrl()
    );
}

/**
 * Attach to a specific target for debugging
 * @param targetId ID of the target to attach to
 * @return Command returning SessionID for the debugging session
 */
public Command<SessionID> attachToTarget(TargetID targetId);

/**
 * Detach from a target and end debugging session
 * @param sessionId Optional session ID to detach from
 * @param targetId Optional target ID to detach from
 * @return Command to detach from target
 */
public Command<Void> detachFromTarget(Optional<SessionID> sessionId, Optional<TargetID> targetId);

import org.openqa.selenium.devtools.idealized.target.model.SessionID;
import org.openqa.selenium.devtools.idealized.target.model.TargetID;
import java.util.Optional;

// Attach to first available page target
List<TargetInfo> targets = devTools.send(target.getTargets());
Optional<TargetInfo> pageTarget = targets.stream()
    .filter(t -> "page".equals(t.getType()))
    .findFirst();

if (pageTarget.isPresent()) {
    TargetID targetId = pageTarget.get().getTargetId();
    SessionID sessionId = devTools.send(target.attachToTarget(targetId));
    
    System.out.println("Attached to target with session: " + sessionId);
    
    // Later, detach from the target
    devTools.send(target.detachFromTarget(Optional.of(sessionId), Optional.of(targetId)));
}

/**
 * Set automatic attachment to new targets
 * Automatically attaches to new pages, workers, and other targets
 * @return Command to enable auto-attachment
 */
public Command<Void> setAutoAttach();

// Enable auto-attachment to new targets
devTools.send(target.setAutoAttach());

// Listen for target detachment events
devTools.addListener(target.detached(), (TargetID detachedTargetId) -> {
    System.out.println("Target detached: " + detachedTargetId);
});

/**
 * Get the target detached event for monitoring target lifecycle
 * @return Event for monitoring target detachment
 */
public Event<TargetID> detached();

// From org.openqa.selenium.devtools.idealized.target.model.TargetInfo
public class TargetInfo {
    public TargetInfo(TargetID targetId, String type, String title, String url, 
                     Boolean attached, Optional<TargetID> openerId, 
                     Optional<BrowserContextID> browserContextId);
    
    public TargetID getTargetId();                          // Unique target identifier
    public String getType();                                // Target type (page, worker, etc.)
    public String getTitle();                               // Target title
    public String getUrl();                                 // Target URL
    public Boolean getAttached();                           // Whether target is attached
    public Optional<TargetID> getOpenerId();               // ID of target that opened this one
    public Optional<BrowserContextID> getBrowserContextId(); // Browser context ID
}

// From org.openqa.selenium.devtools.idealized.target.model.TargetID
public class TargetID {
    public TargetID(String id);
    public String toString();                               // String representation of target ID
}

// From org.openqa.selenium.devtools.idealized.target.model.SessionID  
public class SessionID {
    public SessionID(String id);
    public String toString();                               // String representation of session ID
}

// From org.openqa.selenium.devtools.idealized.browser.model.BrowserContextID
public class BrowserContextID {
    public BrowserContextID(String id);
    public String toString();                               // String representation of context ID
}

import java.util.HashMap;
import java.util.Map;

public class MultiTargetManager {
    private final Map<TargetID, SessionID> activeSessions = new HashMap<>();
    private final v133Target target = new v133Target();
    
    public void attachToAllPageTargets(DevTools devTools) {
        List<TargetInfo> targets = devTools.send(target.getTargets());
        
        targets.stream()
            .filter(t -> "page".equals(t.getType()))
            .forEach(targetInfo -> {
                try {
                    SessionID sessionId = devTools.send(target.attachToTarget(targetInfo.getTargetId()));
                    activeSessions.put(targetInfo.getTargetId(), sessionId);
                    System.out.printf("Attached to page: %s (Session: %s)%n", 
                        targetInfo.getTitle(), sessionId);
                } catch (Exception e) {
                    System.err.printf("Failed to attach to target %s: %s%n", 
                        targetInfo.getTargetId(), e.getMessage());
                }
            });
    }
    
    public void detachFromAllTargets(DevTools devTools) {
        activeSessions.forEach((targetId, sessionId) -> {
            try {
                devTools.send(target.detachFromTarget(Optional.of(sessionId), Optional.of(targetId)));
                System.out.println("Detached from target: " + targetId);
            } catch (Exception e) {
                System.err.printf("Failed to detach from target %s: %s%n", targetId, e.getMessage());
            }
        });
        activeSessions.clear();
    }
    
    public Map<TargetID, SessionID> getActiveSessions() {
        return new HashMap<>(activeSessions);
    }
}

import java.util.function.Predicate;

public class TargetSelector {
    private final v133Target target = new v133Target();
    
    public List<TargetInfo> findTargets(DevTools devTools, Predicate<TargetInfo> filter) {
        List<TargetInfo> allTargets = devTools.send(target.getTargets());
        return allTargets.stream()
            .filter(filter)
            .toList();
    }
    
    public Optional<TargetInfo> findMainPage(DevTools devTools) {
        return findTargets(devTools, t -> 
            "page".equals(t.getType()) && 
            !t.getUrl().startsWith("chrome-") &&
            !t.getUrl().equals("about:blank")
        ).stream().findFirst();
    }
    
    public List<TargetInfo> findWorkers(DevTools devTools) {
        return findTargets(devTools, t -> 
            "worker".equals(t.getType()) || 
            "service_worker".equals(t.getType()) ||
            "shared_worker".equals(t.getType())
        );
    }
    
    public List<TargetInfo> findBackgroundPages(DevTools devTools) {
        return findTargets(devTools, t -> 
            "background_page".equals(t.getType())
        );
    }
}

public class TargetLifecycleMonitor {
    private final v133Target target = new v133Target();
    private final Set<TargetID> knownTargets = ConcurrentHashMap.newKeySet();
    
    public void startMonitoring(DevTools devTools) {
        // Enable auto-attachment to detect new targets
        devTools.send(target.setAutoAttach());
        
        // Listen for target detachment
        devTools.addListener(target.detached(), this::handleTargetDetached);
        
        // Periodically check for new targets
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(() -> checkForNewTargets(devTools), 0, 5, TimeUnit.SECONDS);
    }
    
    private void checkForNewTargets(DevTools devTools) {
        try {
            List<TargetInfo> currentTargets = devTools.send(target.getTargets());
            
            for (TargetInfo targetInfo : currentTargets) {
                if (knownTargets.add(targetInfo.getTargetId())) {
                    handleNewTarget(targetInfo);
                }
            }
        } catch (Exception e) {
            System.err.println("Error checking for new targets: " + e.getMessage());
        }
    }
    
    private void handleNewTarget(TargetInfo targetInfo) {
        System.out.printf("🆕 New target detected: %s (%s) - %s%n",
            targetInfo.getTitle(),
            targetInfo.getType(),
            targetInfo.getUrl()
        );
    }
    
    private void handleTargetDetached(TargetID targetId) {
        knownTargets.remove(targetId);
        System.out.println("❌ Target detached: " + targetId);
    }
}

// Create session for specific target
SessionID session = devTools.send(target.attachToTarget(targetId));

// Use session for target-specific operations
// Note: Session management varies by DevTools implementation
// Some operations may require session context switching

// Detach when done
devTools.send(target.detachFromTarget(Optional.of(session), Optional.of(targetId)));