In general, the manifest describes the behavior of an app through attributes. When a section in the manifest does affect the behavior of an app, this is described in the API Reference. for the corresponding namespace.
The data of the manifest is stored in JSON format in the manifest.json file.
The developer creates the file with attributes in different namespaces. It contains, for
example, the app ID, the version, the data sources used, along with the required
components and libraries. The existence of the manifest.json file must
be declared in the component metadata, which is then delivered as part of the
application archive. After delivery, the file is read-only.
The manifest schema defines how you need to maintain the content of the manifest. It also specifies which namespaces and fields are available. The full schema is available as open source in a repository on Github.
When the manifest schema changes, a new version is published alongside the release of
the new SAPUI5 version.
This new SAPUI5 version
understands the updated schema and supports new features. The schema version you use
is defined by the value of _version. The version number follows the
pattern described under Versioning and Maintenance of SAPUI5. In general, a new
version with the same major version number is compatible with the previous one. It
offers new features or marks certain features as deprecated, which you should
migrate. A new major version can remove features that were previously deprecated,
and these must be migrated.
Starting with SAPUI5 1.136, the new major version 2.x.x Using this new version ensures you follow best practices and are prepared for the future. As mentioned earlier, this new major version removes deprecated features. Check the Migration Information for Upgrading the Manifest File to learn about the changes needed to migrate to this version.
The table below shows the relationship between recent SAPUI5 versions and the manifest schema versions.
|
_Version |
SAPUI5 Version |
|---|---|
|
1.4.0 |
>=1.38 |
|
1.17.0 |
>=1.71 |
|
1.28.0 |
>=1.84 |
|
1.37.0 |
>=1.96 |
|
1.48.0 |
>=1.108 |
|
1.51.0 |
>=1.111 |
|
1.60.0 |
>=1.120 |
|
1.61.0 |
>=1.121 |
|
1.62.0 |
>=1.122 |
|
1.63.0 |
>=1.123 |
|
1.64.0 |
>=1.124 |
|
1.65.0 |
>=1.126 |
|
1.66.0 |
>=1.129 |
|
1.67.2 |
>=1.130 |
|
1.68.0 |
>=1.131 |
|
1.69.0 |
>=1.132 |
|
1.70.1 |
>=1.133 |
|
1.72.0 |
>=1.134 |
|
1.72.3 |
>=1.135 |
|
2.0.0 or 1.73.1 |
>=1.136 |
|
2.1.0 or 1.75.1 |
>=1.137 |
|
2.1.0 or 1.76.0 |
>=1.138 |
|
2.1.0 or 1.77.0 |
>=1.139 |
|
2.1.1 or 1.78.0 |
>=1.140 |
|
2.2.0 or 1.79.0 |
>=1.141 |
|
2.3.1 or 1.80.1 |
>=1.142 |
|
2.3.1 or 1.81.1 |
>=1.143 |
|
2.4.0 or 1.82.0 |
>=1.144 |
For more information on the new fields introduced in each version and implications when upgrading, check out Migration Information for Upgrading the Manifest File.
For more information about Manifest releases, versions, and the supported and deprecated manifest sections, refer to the documentation Manifest Changelog.
By default, all modern component instantiation methods load the
manifest.json file before creating the component instance. This approach enables preloading of dependencies
(libraries and components), thereby improving component loading performance. Additionally, OData models can be configured with
preload: true to ensure the early loading of metadata and annotations during component initialization.
The manifest option allows you to configure when and from where the manifest
is loaded:
Default, equivalent to setting manifest to
true.
// "Component" required from module "sap/ui/core/Component"
// load manifest.json from default location and evaluate it before creating an instance of the component
Component.create({
name: "sap.my.component",
});manifest for the
component factory
function:// "Component" required from module "sap/ui/core/Component"
// load via manifest URL
Component.create({
name: "sap.my.component",
manifest: "any/location/sap/my/component/manifest.json"
});There are two possible scenarios for setting the manifest
flag to false:
The component defines manifest: "json" in its
Component Metadata.
In this case, the manifest is loaded and evaluated after the Component controller. All dependencies defined in the manifest will then also be loaded. Afterwards, the Component is instantiated.
The component does not define manifest: "json"
in its Component Metadata.
This is typically the case for older legacy Components without a manifest. In this case, only the Component's class metadata is evaluated. No additional manifest file will be loaded.
// "Component" required from module "sap/ui/core/Component"
// load component without loading a manifest first
// - Case 1: the manifest.json is loaded after the Component controller
// - Case 2: no manifest.json is loaded (legacy)
Component.create({
name: "sap.my.component",
manifest: false
});When you enable manifest, all legacy component metadata needs to be
migrated into the manifest for applications/components. Only those entries in the
manifest for components will be respected by the component and all other entries
will be ignored.
ui5://
URLsInside the manifest, you can use special URLs prefixed with ui5://. These URLs
will be resolved automatically during component startup before any models are
created.
The ui5://
URLs have the following properties:
ui5://my/path/to/sample, but not
ui5:my/app/path,ui5:// URL must be
registered on the UI5 loader beforehand (see the example below),sap.ui5/resourceRoots can be part of a
ui5:// URL,Component.create takes care of
defining the resource roots before any ui5:// URLs are
resolved.One common use case is the resolution of local annotation files. By default the
local annotation files are resolved relative to the manifest. When using a
ui5:// URL, you can enforce a different resolution, e.g. to
a server-absolute URL.
In this sample, we make sure that the component location is registered as a path
on the UI5 loader. Additionally, we assume that the host system is
http://localhost:8080 :
sap.ui.loader.config({
paths: {
"my/url/prefix": "this/url/is/reachable"
}
})The following snippet shows a sample annotation file configuration in the
sap.app/dataSources section of the manifest:
{
...
"sap.app": {
"dataSources": {
"OData": {
"uri": "/path/to/odata/service",
"type": "OData",
"settings": {
"odataVersion": "2.0",
"annotations": ["annotations"]
...
}
},
...
"annotations": {
"uri": "ui5://my/url/prefix/annotations.xml",
"type": "ODataAnnotation"
}
...
}
}
...
}During startup of the respective component the resolution of the
ui5:// URL for the sample annotation will look like
this:
ui5://my/url/prefix/annotations.xml
is resolved to:
http://localhost:8080/this/url/is/reachable/annotations.xml
You can find an example manifest.json file with sample code for the
manifest content here.
The content for the is contained in the following namespaces: without,
sap.app, sap.ui,
sap.ui5, sap.platform.abap,
sap.platform.hcp, and sap.fiori. The
following tables show the application-specific attributes provided by the respective
namespaces:
sap.uisap.ui namespace|
Attribute |
Description |
|---|---|
|
|
A mandatory attribute that specifies the UI technology; value is
|
|
|
Contains object with app-specific icons, which are:
|
|
|
Mandatory; contains objects with device types on which the app is running, such as:
|
|
|
Indicates whether SAP Fiori launchpad shall render the target
application utilizing the full width of the viewport
(
This parameter is currently subject to SAP Fiori
launchpad only and has no effect on standalone or SAP
Fiori elements applications. Standalone applications can
use |
Current version of the manifest.json
The following sample contains the full scope of all
available manifest properties. Some properties might not be
applicable for all manifest.json variants. For example, the
sap.ui5/models
},
"liabilities": {,
"cdsService": {
"uri": "/sap/bc/ina/ina1/sap/ex section is not supported for library
"settings": {
"localUri": "localServi
For the following namespaces, the indicated teams are responsible:
sap.mobile - in Mobile responsibility
sap.flp - in SAP Fiori launchpad responsibility
sap.ui.generic.app - in SAP Fiori elements responsibility
sap.ovp - in Overview Page responsibility
sap.ui.smartbusiness.app - in Smart Business responsibility
sap.wda - in Web Dynpro ABAP responsibility
sap.gui - in SAP GUI responsibility
sap.cloud.portal - in SAP BTP responsibility
sap.apf - in Analysis Path Framework responsibility
sap.platform.cf - in Cloud Foundry/XSA responsibility
sap.copilot - in Copilot responsibility
sap.map - in SAP Visual Business responsibility
sap.url - in SAP Fiori launchpad responsibility
sap.platform.sfsf - for SAP SuccessFactors specific attributes
sap.wcf - for WCF Application specific attributes
sap.cloud - for SAP BTP-specific attributes
sap.integration - in Application Integration responsibility
sap.platform.mobilecards - in Mobile Cards responsibility
sap.artifact - in SAP Work Zone responsibility
sap.package - in SAP Work Zone responsibility
sap.insights - for My Insights inside My Home
sap.bpa.task - in SAP Build Process Automation responsibility
sap.fe - in SAP Fiori elements responsibility
sap.card - in SAPUI5 responsibility
sap.cards.ap - in Cards for signature micro experience responsibility
The component declares the existence of the manifest by specifying manifest:
"json" in the component metadata. Setting this flag makes the component
load the manifest.json file and read the relevant entries for SAPUI5. This metadata
is used to define the dependencies that need to be loaded in order to start the
component. The following code snippet shows how to add the manifest link:
sap.ui.define([
"sap/ui/core/UIComponent"
], (UIComponent) => {
"use strict";
return UIComponent.extend("my.sample.Component", {
metadata: {
manifest: "json",
interfaces: [
"sap.ui.core.IAsyncContentCreation"
]
}
});
});At runtime, the manifest content can be accessed from the component via the following sap.ui.core.Component APIs:
// Given: oComponent === instance of sap.ui.core.Component (e.g. returned by sap.ui.core.mvc.Controller#getOwnerComponent)
oComponent.getManifest(); // returns reference to the entire manifest object if it exists; otherwise returns null
oComponent.getManifestEntry("sap.app"); // returns reference to the configuration section of the manifest
oComponent.getManifestEntry("/sap.ui5/dependencies/libs"); // returns reference or value of the manifest configuration by path; the syntax must start with a slash