- User Data Profiles
- Credit Cards
- Spell Checker
This is an overview of the JxBrowser architecture.
The architecture of the JxBrowser library consists of the multiple processes such as Java application process and different Chromium processes:
The following sections provide details for each of the processes, the main components of the library, and describe how it all works.
This is a standard Java process where your Java application runs. Here you work with the JxBrowser API to initialize
Engine, access the default
Profile, create the
Browser instances, load web pages, access
BrowserView into your Java Swing, JavaFX, or SWT desktop application to display content of the loaded web pages, etc.
Chromium uses Multi-Process Architecture and runs multiple processes. Each process has its own type and purpose. Below you can find description of the basic process types.
Chromium decides how many processes should be launched. It might run additional processes for its internal functionality, plugins, extensions, utilities, etc.
This process is started by JxBrowser when you create
Engine. It is the main process that manages the life-cycle of other Chromium processes. If you terminate this process, all other Chromium processes produced by this one will be terminated as well.
Engine instance a separate Chromium Main process is launched.
In this process the
Browser to a web page with a different domain.
By default, each Renderer process runs in Sandbox, so it cannot directly use your disk, network, or display.
In this process the content of the web pages loaded in different Chromium Renderer processes is rendered by Chromium using the GPU.
Communication between different processes is done via Inter-Process Communication (IPC). IPC transfers data between two processes on a local machine.
To transfer data between Java and Chromium processes JxBrowser uses its own IPC implementation based on sockets and shared memory. Communication between Chromium processes is done via Chromium IPC implementation.
Manages the life cycle of the Chromium Main process and provides access to the core Chromium functionality that allows managing profiles, accessing all the available media input devices, etc.
To work with the engine please use the
Engine class. It is a top-level object in the objects’ hierarchy of the library. Working with the library begins with creation of an
For detailed instructions on creation and usage of the
Engine instance see the Engine guide.
Represents a Chromium profile. It allows keeping all browser data separately, like history, cookies, cache, proxy settings, spellchecker configurations, etc. Each
Engine has a default profile that is created automatically during
Engine initialization. The default profile cannot be deleted.
You can create new profiles and delete them if they are not required using the
The profile’s files for history, cookies, cache, etc. are stored in the user data directory. If you configure
Engine with the user data directory and create a profile, it will be stored in the user data directory and be restored after application restart.
Read more about profiles in the Profile guide.
This is a web browser control which is responsible for loading web pages or local HTML files, finding text on the loaded web page, modifying zoom, working with audio, getting notifications about loading progress, dispatching keyboard and mouse events, and more.
To work with this control use the
Browser class. Each
Browser instance belongs to
Browser instance is closed automatically if its
Profile is deleted or its
Engine instance is closed or crashed.
The Browser guide provides details on how to create and use the
Each web page loaded in
Browser has a main
Frame itself may have child frames. You can use
Frame and all child frames are closed automatically.
How it Works
When you create an
Engine instance, the library performs the following actions:
- Start the Chromium Main and GPU processes.
- Initialize Chromium engine in the Chromium Main process.
- Initialize the default profile.
- Setup IPC connection between Java and the Chromium Main process.
If you create two
Engine instances, separate Chromium Main and GPU processes will be started for each instance. For example:
When you create a
Browser instance, the library automatically loads an
If you navigate the
Browser instance to a web page, the page will be loaded in this Chromium Renderer process. If you then load a web page with a different domain, it will be loaded in a new Chromium Renderer process which will be started automatically. And the Chromium Renderer process created for the previous web page will be closed.
If a web page has an
IFRAME with a web page from another domain, Chromium will run a separate Renderer process for this remote frame.
When you close the
Browser instance, the corresponding Chromium Renderer process is terminated automatically. It means that all the
Frame instances running in the terminated process will be automatically closed as well:
When you close the
Engine, the library performs the following actions:
- Close IPC connection between Java and the Chromium Main processes.
- Dispose Chromium engine in the Chromium Main process.
- Terminate the Chromium Main and GPU processes.