RedBoxVM API Reference

Complete API documentation for integrating RedBoxVM into your applications. This reference covers all public APIs, interfaces, and integration patterns.

Core Classes

RedBoxManager

The main entry point for all RedBoxVM operations.

public class RedBoxManager {
    // Singleton instance
    public static RedBoxManager getInstance()
    
    // Initialize the virtualization engine
    public void initialize(Context context)
    
    // Create a new virtual environment
    public VirtualEnvironment createEnvironment(String packageName)
    
    // Launch an app in virtual environment
    public boolean launchApp(VirtualEnvironment env, String packageName)
    
    // Get all virtual environments
    public List<VirtualEnvironment> getEnvironments()
    
    // Destroy a virtual environment
    public void destroyEnvironment(VirtualEnvironment env)
}

Usage Example

// Initialize RedBoxVM
RedBoxManager manager = RedBoxManager.getInstance();
manager.initialize(this);

// Create virtual environment for WhatsApp
VirtualEnvironment whatsappEnv = manager.createEnvironment("com.whatsapp");

// Launch WhatsApp in virtual environment
boolean success = manager.launchApp(whatsappEnv, "com.whatsapp");

if (success) {
    Log.d("RedBox", "WhatsApp launched successfully in virtual environment");
}

VirtualEnvironment

Represents an isolated virtual environment for running apps.

public class VirtualEnvironment {
    // Get environment ID
    public String getId()
    
    // Get associated package name
    public String getPackageName()
    
    // Check if environment is active
    public boolean isActive()
    
    // Get environment configuration
    public EnvironmentConfig getConfig()
    
    // Set environment configuration
    public void setConfig(EnvironmentConfig config)
    
    // Get virtual file system path
    public String getVirtualPath()
    
    // Get running processes in this environment
    public List<ProcessInfo> getProcesses()
}

EnvironmentConfig

Configuration options for virtual environments.

public class EnvironmentConfig {
    // Network isolation settings
    public boolean networkIsolation = true;
    
    // File system isolation
    public boolean fileSystemIsolation = true;
    
    // Custom storage path
    public String customStoragePath = null;
    
    // Memory limit (MB)
    public int memoryLimit = 512;
    
    // Enable debugging
    public boolean debugMode = false;
    
    // VPN configuration
    public VpnConfig vpnConfig = null;
}

Event Listeners

AppListener

Listen to virtual app lifecycle events.

public interface AppListener {
    void onAppStarted(String packageName, VirtualEnvironment env);
    void onAppStopped(String packageName, VirtualEnvironment env);
    void onAppCrashed(String packageName, VirtualEnvironment env, Exception error);
    void onEnvironmentCreated(VirtualEnvironment env);
    void onEnvironmentDestroyed(VirtualEnvironment env);
}

Implementation Example

manager.setAppListener(new AppListener() {
    @Override
    public void onAppStarted(String packageName, VirtualEnvironment env) {
        Log.d("RedBox", "App started: " + packageName + " in env: " + env.getId());
        // Update UI, send analytics, etc.
    }
    
    @Override
    public void onAppCrashed(String packageName, VirtualEnvironment env, Exception error) {
        Log.e("RedBox", "App crashed: " + packageName, error);
        // Handle crash, show error dialog, etc.
    }
    
    // ... implement other methods
});

API Flow Diagram

Understanding the typical API usage flow:

Advanced APIs

ProcessManager

Advanced process management within virtual environments.

public class ProcessManager {
    // Get process manager instance
    public static ProcessManager getInstance()
    
    // Kill a specific process
    public boolean killProcess(VirtualEnvironment env, int pid)
    
    // Get process information
    public ProcessInfo getProcessInfo(VirtualEnvironment env, int pid)
    
    // Monitor process resource usage
    public void startResourceMonitoring(VirtualEnvironment env, ResourceListener listener)
    
    // Set process priority
    public void setProcessPriority(VirtualEnvironment env, int pid, int priority)
}

FileSystemManager

Virtual file system operations.

public class FileSystemManager {
    // Copy file between environments
    public boolean copyFile(VirtualEnvironment source, VirtualEnvironment dest, String path)
    
    // Get virtual file system usage
    public StorageInfo getStorageInfo(VirtualEnvironment env)
    
    // Clean up temporary files
    public void cleanupTempFiles(VirtualEnvironment env)
    
    // Export environment data
    public boolean exportEnvironment(VirtualEnvironment env, String exportPath)
    
    // Import environment data
    public VirtualEnvironment importEnvironment(String importPath)
}

Error Handling

Exception Types

Error Handling Example

try {
    VirtualEnvironment env = manager.createEnvironment("com.example.app");
    boolean success = manager.launchApp(env, "com.example.app");
    
    if (!success) {
        throw new AppLaunchException("Failed to launch app");
    }
    
} catch (VirtualizationException e) {
    Log.e("RedBox", "Virtualization error", e);
    // Show user-friendly error message
    showErrorDialog("Virtualization failed: " + e.getMessage());
    
} catch (AppLaunchException e) {
    Log.e("RedBox", "App launch error", e);
    // Handle app-specific launch issues
    handleAppLaunchError(e);
    
} catch (Exception e) {
    Log.e("RedBox", "Unexpected error", e);
    // Handle unexpected errors
    crashlytics.recordException(e);
}

Configuration Options

Global Configuration

public class RedBoxConfig {
    // Maximum number of concurrent virtual environments
    public static final int MAX_ENVIRONMENTS = 10;
    
    // Default memory limit per environment (MB)
    public static final int DEFAULT_MEMORY_LIMIT = 512;
    
    // Enable performance monitoring
    public boolean performanceMonitoring = false;
    
    // Log level
    public LogLevel logLevel = LogLevel.INFO;
    
    // Custom hook configurations
    public Map<String, HookConfig> customHooks = new HashMap<>();
}

Network Configuration

public class NetworkConfig {
    // Enable network isolation
    public boolean isolateNetwork = true;
    
    // Custom DNS servers
    public List<String> dnsServers = Arrays.asList("8.8.8.8", "8.8.4.4");
    
    // Proxy configuration
    public ProxyConfig proxyConfig = null;
    
    // VPN integration
    public boolean enableVpnIntegration = false;
    
    // Network monitoring
    public boolean monitorNetworkTraffic = false;
}

Performance Monitoring

ResourceMonitor

public class ResourceMonitor {
    // Start monitoring resources
    public void startMonitoring(VirtualEnvironment env, ResourceListener listener)
    
    // Get current resource usage
    public ResourceUsage getCurrentUsage(VirtualEnvironment env)
    
    // Get historical resource data
    public List<ResourceUsage> getHistoricalData(VirtualEnvironment env, long timeRange)
    
    // Set resource limits
    public void setResourceLimits(VirtualEnvironment env, ResourceLimits limits)
}

ResourceUsage Data Structure

public class ResourceUsage {
    public long timestamp;
    public int memoryUsageMB;
    public float cpuUsagePercent;
    public long networkBytesIn;
    public long networkBytesOut;
    public long storageUsedMB;
    public int activeProcesses;
}

Integration Patterns

Singleton Pattern

public class MyRedBoxIntegration {
    private static MyRedBoxIntegration instance;
    private RedBoxManager redBoxManager;
    
    private MyRedBoxIntegration() {
        redBoxManager = RedBoxManager.getInstance();
    }
    
    public static MyRedBoxIntegration getInstance() {
        if (instance == null) {
            synchronized (MyRedBoxIntegration.class) {
                if (instance == null) {
                    instance = new MyRedBoxIntegration();
                }
            }
        }
        return instance;
    }
}

Observer Pattern

public class VirtualAppObserver implements AppListener {
    private List<VirtualAppCallback> callbacks = new ArrayList<>();
    
    public void addCallback(VirtualAppCallback callback) {
        callbacks.add(callback);
    }
    
    @Override
    public void onAppStarted(String packageName, VirtualEnvironment env) {
        for (VirtualAppCallback callback : callbacks) {
            callback.onVirtualAppEvent(packageName, env, "STARTED");
        }
    }
}