@ohos.window (Window)

The Window module provides basic window management capabilities, such as creating and destroying the current window, setting properties for the current window, and managing and scheduling windows.

This module provides the following common window-related functionalities:

• Window: window instance, which is the basic unit managed by the window manager.
• WindowStage: window manager that manages windows.

NOTE

The initial APIs of this module are supported since API version 6. Newly added APIs will be marked with a superscript to indicate their earliest API version.

Modules to Import

import window from '@ohos.window';

WindowType⁷⁺

Enumerates the window types.

System capability: SystemCapability.WindowManager.WindowManager.Core

Configuration⁹⁺

Defines the parameters for creating a subwindow or system window.

System capability: SystemCapability.WindowManager.WindowManager.Core

AvoidAreaType⁷⁺

Enumerates the types of the area where the window cannot be displayed.

System capability: SystemCapability.WindowManager.WindowManager.Core

SystemBarProperties

Describes the properties of the status bar and navigation bar.

System capability: SystemCapability.WindowManager.WindowManager.Core

Orientation⁹⁺

Enumerates the window orientations.

System capability: SystemCapability.WindowManager.WindowManager.Core

Rect⁷⁺

Describes the rectangular area of the window.

System capability: SystemCapability.WindowManager.WindowManager.Core

AvoidArea⁷⁺

Describes the area where the window cannot be displayed, for example, the system bar area, notch, gesture area, and soft keyboard area. Touch events will not be responded in this area.

Pay attention to the following restrictions on this area:

• The non-navigation bar area in the gesture area at the bottom supports transparent transmission of touch events, touch and hold events, but not drag events.

• The gesture area on the left and right sides supports transparent transmission of touch events, touch and hold events, and swipe up and down events, but not drag events.

• The navigation bar area supports responding to touch events, touch and hold events, and drag events. However, it does not support transparent transmission of events.

System capability: SystemCapability.WindowManager.WindowManager.Core

Size⁷⁺

Describes the window size.

System capability: SystemCapability.WindowManager.WindowManager.Core

WindowProperties

Describes the window properties.

System capability: SystemCapability.WindowManager.WindowManager.Core

ColorSpace⁸⁺

Enumerates the color spaces.

System capability: SystemCapability.WindowManager.WindowManager.Core

WindowEventType¹⁰⁺

Enumerates the window lifecycle states.

WindowLimits¹¹⁺

Defines the window size limits.

System capability: SystemCapability.Window.SessionManager

WindowStatusType¹¹⁺

Enumerates the window modes.

System capability: SystemCapability.Window.SessionManager

TitleButtonRect¹¹⁺

Defines the rectangle used to hold the minimize, maximize, and close buttons on the title bar. This rectangle is located in the upper right corner of the window.

System capability: SystemCapability.Window.SessionManager

window.createWindow⁹⁺

createWindow(config: Configuration, callback: AsyncCallback<Window>): void

Creates a subwindow or system window. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
let config: window.Configuration = {
  name: "test",
  windowType: window.WindowType.TYPE_DIALOG,
  ctx: this.context
};
try {
  window.createWindow(config, (err: BusinessError, data) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to create the window. Cause: ' + JSON.stringify(err));
      return;
    }
    windowClass = data;
    console.info('Succeeded in creating the window. Data: ' + JSON.stringify(data));
    windowClass.resize(500, 1000);
  });
} catch (exception) {
  console.error('Failed to create the window. Cause: ' + JSON.stringify(exception));
}

window.createWindow⁹⁺

createWindow(config: Configuration): Promise<Window>

Creates a subwindow or system window. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
let config: window.Configuration = {
  name: "test",
  windowType: window.WindowType.TYPE_DIALOG,
  ctx: this.context
};
try {
  let promise = window.createWindow(config);
  promise.then((data) => {
    windowClass = data;
    console.info('Succeeded in creating the window. Data:' + JSON.stringify(data));
  }).catch((err: BusinessError) => {
    console.error('Failed to create the Window. Cause:' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to create the window. Cause: ' + JSON.stringify(exception));
}

window.findWindow⁹⁺

findWindow(name: string): Window

Finds a window based on the name.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

let windowClass: window.Window | undefined = undefined;
try {
  windowClass = window.findWindow('test');
} catch (exception) {
  console.error('Failed to find the Window. Cause: ' + JSON.stringify(exception));
}

window.getLastWindow⁹⁺

getLastWindow(ctx: BaseContext, callback: AsyncCallback<Window>): void

Obtains the top window of the current application. This API uses an asynchronous callback to return the result. If no subwindow is available, the main window of the application is returned.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { BusinessError } from '@ohos.base';

export default class EntryAbility extends UIAbility {
  // ...
  onWindowStageCreate(windowStage: window.WindowStage) {
    console.info('onWindowStageCreate');
    let windowClass: window.Window | undefined = undefined;
    try {
      window.getLastWindow(this.context, (err: BusinessError, data) => {
        const errCode: number = err.code;
        if (errCode) {
          console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(err));
          return;
        }
        windowClass = data;
        console.info('Succeeded in obtaining the top window. Data: ' + JSON.stringify(data));
      });
    } catch (exception) {
      console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(exception));
    }
  }
}

window.getLastWindow⁹⁺

getLastWindow(ctx: BaseContext): Promise<Window>

Obtains the top window of the current application. This API uses a promise to return the result. If no subwindow is available, the main window of the application is returned.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { BusinessError } from '@ohos.base';

export default class EntryAbility extends UIAbility {
  // ...
  onWindowStageCreate(windowStage: window.WindowStage) {
    console.info('onWindowStageCreate');
    let windowClass: window.Window | undefined = undefined;
    try {
      let promise = window.getLastWindow(this.context);
      promise.then((data) => {
        windowClass = data;
        console.info('Succeeded in obtaining the top window. Data: ' + JSON.stringify(data));
      }).catch((err: BusinessError) => {
        console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(err));
      });
    } catch (exception) {
      console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(exception));
    }
  }
}

window.shiftAppWindowFocus¹¹⁺

shiftAppWindowFocus(sourceWindowId: number, targetWindowId: number): Promise<void>

Shifts the window focus from the source window to the target window in the same application. The window focus can be shifted between the main window and a subwindow.

System capability: SystemCapability.Window.SessionManager

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let sourceWindowId: number = 40;
  let targetWindowId: number = 41;
  let promise = window.shiftAppWindowFocus(sourceWindowId, targetWindowId);
  promise.then(() => {
    console.info('Succeeded in shifting app window focus');
  }).catch((err: BusinessError) => {
    console.error('Failed to shift app window focus. Cause:' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to shift app window focus. Cause:' + JSON.stringify(exception));
}

window.create^(deprecated)

create(id: string, type: WindowType, callback: AsyncCallback<Window>): void

Creates a subwindow. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use createWindow() instead.

Model restriction: This API can be used only in the FA model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
window.create('test', window.WindowType.TYPE_APP, (err: BusinessError, data) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to create the subWindow. Cause: ' + JSON.stringify(err));
    return;
  }
  windowClass = data;
  console.info('Succeeded in creating the subWindow. Data: ' + JSON.stringify(data));
});

window.create^(deprecated)

create(id: string, type: WindowType): Promise<Window>

Creates a subwindow. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use createWindow() instead.

Model restriction: This API can be used only in the FA model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
let promise = window.create('test', window.WindowType.TYPE_APP);
promise.then((data) => {
  windowClass = data;
  console.info('Succeeded in creating the subWindow. Data: ' + JSON.stringify(data));
}).catch((err: BusinessError) => {
  console.error('Failed to create the subWindow. Cause: ' + JSON.stringify(err));
});

window.create^(deprecated)

create(ctx: BaseContext, id: string, type: WindowType, callback: AsyncCallback<Window>): void

Creates a system window. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use createWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
window.create('test', window.WindowType.TYPE_SYSTEM_ALERT, (err: BusinessError, data) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to create the window. Cause: ' + JSON.stringify(err));
    return;
  }
  windowClass = data;
  console.info('Succeeded in creating the window. Data: ' + JSON.stringify(data));
  windowClass.resetSize(500, 1000);
});

window.create^(deprecated)

create(ctx: BaseContext, id: string, type: WindowType): Promise<Window>

Creates a system window. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use createWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
let promise = window.create('test', window.WindowType.TYPE_SYSTEM_ALERT);
promise.then((data) => {
  windowClass = data;
  console.info('Succeeded in creating the window. Data:' + JSON.stringify(data));
}).catch((err: BusinessError) => {
  console.error('Failed to create the Window. Cause:' + JSON.stringify(err));
});

window.find^(deprecated)

find(id: string, callback: AsyncCallback<Window>): void

Finds a window based on the ID. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use findWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
window.find('test', (err: BusinessError, data) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to find the Window. Cause: ' + JSON.stringify(err));
    return;
  }
  windowClass = data;
  console.info('Succeeded in finding the window. Data: ' + JSON.stringify(data));
});

window.find^(deprecated)

find(id: string): Promise<Window>

Finds a window based on the ID. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use findWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
let promise = window.find('test');
promise.then((data) => {
  windowClass = data;
  console.info('Succeeded in finding the window. Data: ' + JSON.stringify(data));
}).catch((err: BusinessError) => {
  console.error('Failed to find the Window. Cause: ' + JSON.stringify(err));
});

window.getTopWindow^(deprecated)

getTopWindow(callback: AsyncCallback<Window>): void

Obtains the top window of the current application. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 6 and deprecated since API version 9. You are advised to use getLastWindow() instead.

Model restriction: This API can be used only in the FA model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
window.getTopWindow((err: BusinessError, data) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(err));
    return;
  }
  windowClass = data;
  console.info('Succeeded in obtaining the top window. Data: ' + JSON.stringify(data));
});

window.getTopWindow^(deprecated)

getTopWindow(): Promise<Window>

Obtains the top window of the current application. This API uses a promise to return the result.

NOTE

This API is supported since API version 6 and deprecated since API version 9. You are advised to use getLastWindow() instead.

Model restriction: This API can be used only in the FA model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Example

import { BusinessError } from '@ohos.base';

let windowClass: window.Window | undefined = undefined;
let promise = window.getTopWindow();
promise.then((data)=> {
  windowClass = data;
  console.info('Succeeded in obtaining the top window. Data: ' + JSON.stringify(data));
}).catch((err: BusinessError)=>{
  console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(err));
});

window.getTopWindow^(deprecated)

getTopWindow(ctx: BaseContext, callback: AsyncCallback<Window>): void

Obtains the top window of the current application. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use getLastWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

export default class EntryAbility extends UIAbility {
  onWindowStageCreate(windowStage:window.WindowStage){
    console.info('onWindowStageCreate');
    let windowClass: window.Window | undefined = undefined;
    try {
      window.getTopWindow(this.context, (err: BusinessError, data) => {
        const errCode: number = err.code;
        if(errCode){
          console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(err));
          return ;
        }
        windowClass = data;
        console.info('Succeeded in obtaining the top window. Data: ' + JSON.stringify(data));
      });
    } catch(error){
      console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(error));
    }
  }
}

window.getTopWindow^(deprecated)

getTopWindow(ctx: BaseContext): Promise<Window>

Obtains the top window of the current application. This API uses a promise to return the result.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use getLastWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Example

import { BusinessError } from '@ohos.base';

export default class EntryAbility extends UIAbility {
  onWindowStageCreate(windowStage:window.WindowStage) {
    console.info('onWindowStageCreate');
    let windowClass: window.Window | undefined = undefined;
    let promise = window.getTopWindow(this.context);
    promise.then((data) => {
      windowClass = data;
      console.info('Succeeded in obtaining the top window. Data: ' + JSON.stringify(data));
    }).catch((error: BusinessError) => {
      console.error('Failed to obtain the top window. Cause: ' + JSON.stringify(error));
    });
  }
}

SpecificSystemBar¹¹⁺

Enumerates the types of system bars that can be displayed or hidden.

System capability: SystemCapability.Window.SessionManager

Window

Represents a window instance, which is the basic unit managed by the window manager.

In the following API examples, you must use getLastWindow(), createWindow(), or findWindow() to obtain a Window instance (named windowClass in this example) and then call a method in this instance.

showWindow⁹⁺

showWindow(callback: AsyncCallback<void>): void

Shows this window. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

windowClass.showWindow((err: BusinessError) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to show the window. Cause: ' + JSON.stringify(err));
    return;
  }
  console.info('Succeeded in showing the window.');
});

showWindow⁹⁺

showWindow(): Promise<void>

Shows this window. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let promise = windowClass.showWindow();
promise.then(() => {
  console.info('Succeeded in showing the window.');
}).catch((err: BusinessError) => {
  console.error('Failed to show the window. Cause: ' + JSON.stringify(err));
});

destroyWindow⁹⁺

destroyWindow(callback: AsyncCallback<void>): void

Destroys this window. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

windowClass.destroyWindow((err) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to destroy the window. Cause:' + JSON.stringify(err));
    return;
  }
  console.info('Succeeded in destroying the window.');
});

destroyWindow⁹⁺

destroyWindow(): Promise<void>

Destroys this window. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let promise = windowClass.destroyWindow();
promise.then(() => {
  console.info('Succeeded in destroying the window.');
}).catch((err: BusinessError) => {
  console.error('Failed to destroy the window. Cause: ' + JSON.stringify(err));
});

moveWindowTo⁹⁺

moveWindowTo(x: number, y: number, callback: AsyncCallback<void>): void

Moves this window. This API uses an asynchronous callback to return the result.

This operation is not supported in a window in full-screen mode.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  windowClass.moveWindowTo(300, 300, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to move the window. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in moving the window.');
  });
} catch (exception) {
  console.error('Failed to move the window. Cause:' + JSON.stringify(exception));
}

moveWindowTo⁹⁺

moveWindowTo(x: number, y: number): Promise<void>

Moves this window. This API uses a promise to return the result.

This operation is not supported in a window in full-screen mode.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let promise = windowClass.moveWindowTo(300, 300);
  promise.then(() => {
    console.info('Succeeded in moving the window.');
  }).catch((err: BusinessError) => {
    console.error('Failed to move the window. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to move the window. Cause:' + JSON.stringify(exception));
}

resize⁹⁺

resize(width: number, height: number, callback: AsyncCallback<void>): void

Changes the size of this window. This API uses an asynchronous callback to return the result.

The main window and subwindow have the following default size limits: [320, 1920] in width and [240, 1920] in height, both in units of vp.

The minimum width and height of the main window and subwindow of the application depends on the configuration on the product side. You can call getWindowLimits to obtain size limits.

The system window has the following size limits: [0, 1920] in width and [0, 1920] in height, both in units of vp.

The window width and height you set must meet the limits. The rules are as follows:

• If the window width or height you set is less than the minimum width or height limit, then the minimum width or height limit takes effect.
• If the window width or height you set is greater than the maximum width or height limit, then the maximum width or height limit takes effect.

This operation is not supported in a window in full-screen mode.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  windowClass.resize(500, 1000, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to change the window size. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in changing the window size.');
  });
} catch (exception) {
  console.error('Failed to change the window size. Cause:' + JSON.stringify(exception));
}

resize⁹⁺

resize(width: number, height: number): Promise<void>

Changes the size of this window. This API uses a promise to return the result.

The main window and subwindow have the following default size limits: [320, 1920] in width and [240, 1920] in height, both in units of vp.

The minimum width and height of the main window and subwindow of the application depends on the configuration on the product side. You can call getWindowLimits to obtain size limits.

The system window has the following size limits: [0, 1920] in width and [0, 1920] in height, both in units of vp.

The window width and height you set must meet the limits. The rules are as follows:

• If the window width or height you set is less than the minimum width or height limit, then the minimum width or height limit takes effect.
• If the window width or height you set is greater than the maximum width or height limit, then the maximum width or height limit takes effect.

This operation is not supported in a window in full-screen mode.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let promise = windowClass.resize(500, 1000);
  promise.then(() => {
    console.info('Succeeded in changing the window size.');
  }).catch((err: BusinessError) => {
    console.error('Failed to change the window size. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to change the window size. Cause: ' + JSON.stringify(exception));
}

getWindowProperties⁹⁺

getWindowProperties(): WindowProperties

Obtains the properties of this window.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  let properties = windowClass.getWindowProperties();
} catch (exception) {
  console.error('Failed to obtain the window properties. Cause: ' + JSON.stringify(exception));
}

getWindowAvoidArea⁹⁺

getWindowAvoidArea(type: AvoidAreaType): AvoidArea

Obtains the area where this window cannot be displayed, for example, the system bar area, notch, gesture area, and soft keyboard area.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

let type = window.AvoidAreaType.TYPE_SYSTEM;
try {
  let avoidArea = windowClass.getWindowAvoidArea(type);
} catch (exception) {
  console.error('Failed to obtain the area. Cause:' + JSON.stringify(exception));
}

setWindowLayoutFullScreen⁹⁺

setWindowLayoutFullScreen(isLayoutFullScreen: boolean, callback: AsyncCallback<void>): void

Sets whether the window layout is immersive. This API uses an asynchronous callback to return the result. An immersive layout means that the layout does not avoid the status bar and navigation bar, and components may overlap with them. A non-immersive layout means that the layout avoids the status bar and navigation bar, and components do not overlap with them.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isLayoutFullScreen = true;
try {
  windowClass.setWindowLayoutFullScreen(isLayoutFullScreen, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the window layout to full-screen mode. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the window layout to full-screen mode.');
  });
} catch (exception) {
  console.error('Failed to set the window layout to full-screen mode. Cause:' + JSON.stringify(exception));
}

setWindowLayoutFullScreen⁹⁺

setWindowLayoutFullScreen(isLayoutFullScreen: boolean): Promise<void>

Sets whether the window layout is immersive. This API uses a promise to return the result. An immersive layout means that the layout does not avoid the status bar and navigation bar, and components may overlap with them. A non-immersive layout means that the layout avoids the status bar and navigation bar, and components do not overlap with them.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isLayoutFullScreen = true;
try {
  let promise = windowClass.setWindowLayoutFullScreen(isLayoutFullScreen);
  promise.then(() => {
    console.info('Succeeded in setting the window layout to full-screen mode.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the window layout to full-screen mode. Cause:' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the window layout to full-screen mode. Cause:' + JSON.stringify(exception));
}

setWindowSystemBarEnable⁹⁺

setWindowSystemBarEnable(names: Array<'status' | 'navigation'>, callback: AsyncCallback<void>): void

Sets whether to display the status bar and navigation bar when the window is in full-screen mode. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

// In this example, the status bar and navigation bar are not displayed.
import { BusinessError } from '@ohos.base';

let names: Array<'status' | 'navigation'> = [];
try {
  windowClass.setWindowSystemBarEnable(names, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the system bar to be invisible. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the system bar to be invisible.');
  });
} catch (exception) {
  console.error('Failed to set the system bar to be invisible. Cause:' + JSON.stringify(exception));
}

setWindowSystemBarEnable⁹⁺

setWindowSystemBarEnable(names: Array<'status' | 'navigation'>): Promise<void>

Sets whether to display the status bar and navigation bar when the window is in full-screen mode. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

// In this example, the status bar and navigation bar are not displayed.
import { BusinessError } from '@ohos.base';

let names: Array<'status' | 'navigation'> = [];
try {
  let promise = windowClass.setWindowSystemBarEnable(names);
  promise.then(() => {
    console.info('Succeeded in setting the system bar to be invisible.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the system bar to be invisible. Cause:' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the system bar to be invisible. Cause:' + JSON.stringify(exception));
}

setSpecificSystemBarEnabled¹¹⁺

setSpecificSystemBarEnabled(name: SpecificSystemBar, enable: boolean): Promise<void>

Sets whether to show the navigation bar, status bar, or bottom navigation bar in full-screen mode. This API uses a promise to return the result.

System capability: SystemCapability.Window.SessionManager

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

// Hide the bottom navigation bar.
import { BusinessError } from '@ohos.base';

try {
  let promise = windowClass.setSpecificSystemBarEnabled('navigationIndicator', false);
  promise.then(() => {
    console.info('Succeeded in setting the system bar to be invisible.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the system bar to be invisible. Cause:' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the system bar to be invisible. Cause:' + JSON.stringify(exception));
}

setWindowSystemBarProperties⁹⁺

setWindowSystemBarProperties(systemBarProperties: SystemBarProperties, callback: AsyncCallback<void>): void

Sets the properties of the status bar and navigation bar when the window is in full-screen mode. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let SystemBarProperties: window.SystemBarProperties = {
  statusBarColor: '#ff00ff',
  navigationBarColor: '#00ff00',
  // The following properties are supported since API version 8.
  statusBarContentColor: '#ffffff',
  navigationBarContentColor: '#00ffff'
};
try {
  windowClass.setWindowSystemBarProperties(SystemBarProperties, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the system bar properties. Cause: ' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the system bar properties.');
  });
} catch (exception) {
  console.error('Failed to set the system bar properties. Cause: ' + JSON.stringify(exception));
}

setWindowSystemBarProperties⁹⁺

setWindowSystemBarProperties(systemBarProperties: SystemBarProperties): Promise<void>

Sets the properties of the status bar and navigation bar when the window is in full-screen mode. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let SystemBarProperties: window.SystemBarProperties = {
  statusBarColor: '#ff00ff',
  navigationBarColor: '#00ff00',
  // The following properties are supported since API version 8.
  statusBarContentColor: '#ffffff',
  navigationBarContentColor: '#00ffff'
};
try {
  let promise = windowClass.setWindowSystemBarProperties(SystemBarProperties);
  promise.then(() => {
    console.info('Succeeded in setting the system bar properties.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the system bar properties. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the system bar properties. Cause: ' + JSON.stringify(exception));
}

setPreferredOrientation⁹⁺

setPreferredOrientation(orientation: Orientation, callback: AsyncCallback<void>): void

Sets the preferred orientation for this window. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let orientation = window.Orientation.AUTO_ROTATION;
try {
  windowClass.setPreferredOrientation(orientation, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set window orientation. Cause: ' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting window orientation.');
  });
} catch (exception) {
  console.error('Failed to set window orientation. Cause: ' + JSON.stringify(exception));
}

setPreferredOrientation⁹⁺

setPreferredOrientation(orientation: Orientation): Promise<void>

Sets the preferred orientation for this window. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let orientation = window.Orientation.AUTO_ROTATION;
try {
  let promise = windowClass.setPreferredOrientation(orientation);
  promise.then(() => {
    console.info('Succeeded in setting the window orientation.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the window orientation. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set window orientation. Cause: ' + JSON.stringify(exception));
}

getUIContext¹⁰⁺

getUIContext(): UIContext

Obtain a UIContext instance.

Model restriction: This API can be used only in the stage model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { BusinessError } from '@ohos.base';
import { UIContext } from '@ohos.arkui.UIContext';

export default class EntryAbility extends UIAbility {
  onWindowStageCreate(windowStage: window.WindowStage) {
    // Load content for the main window.
    windowStage.loadContent("pages/page2", (err: BusinessError) => {
      let errCode: number = err.code;
      if (errCode) {
        console.error('Failed to load the content. Cause:' + JSON.stringify(err));
        return;
      }
      console.info('Succeeded in loading the content.');
      // Obtain the main window.
      let windowClass: window.Window | undefined = undefined;
      windowStage.getMainWindow((err: BusinessError, data) => {
        let errCode: number = err.code;
        if (errCode) {
          console.error('Failed to obtain the main window. Cause: ' + JSON.stringify(err));
          return;
        }
        windowClass = data;
        console.info('Succeeded in obtaining the main window. Data: ' + JSON.stringify(data));
        // Obtain a UIContext instance.
        let uiContext: UIContext | null = null;
        uiContext = windowClass.getUIContext();
      })
    });
  }
};

setUIContent⁹⁺

setUIContent(path: string, callback: AsyncCallback<void>): void

Loads the content of a page, with its path in the current project specified, to this window. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  windowClass.setUIContent('pages/page2/page3', (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to load the content. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in loading the content.');
  });
} catch (exception) {
  console.error('Failed to load the content. Cause:' + JSON.stringify(exception));
}

setUIContent⁹⁺

setUIContent(path: string): Promise<void>

Loads the content of a page, with its path in the current project specified, to this window. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let promise = windowClass.setUIContent('pages/page2/page3');
  promise.then(() => {
    console.info('Succeeded in loading the content.');
  }).catch((err: BusinessError) => {
    console.error('Failed to load the content. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to load the content. Cause: ' + JSON.stringify(exception));
}

loadContent⁹⁺

loadContent(path: string, storage: LocalStorage, callback: AsyncCallback<void>): void

Loads the content of a page, with its path in the current project specified, to this window, and transfers the state attribute to the page through a local storage. This API uses an asynchronous callback to return the result.

Model restriction: This API can be used only in the stage model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { BusinessError } from '@ohos.base';

export default class EntryAbility extends UIAbility {
  // ...

  onWindowStageCreate(windowStage: window.WindowStage) {
    console.info('onWindowStageCreate');
    let storage: LocalStorage = new LocalStorage();
    storage.setOrCreate('storageSimpleProp', 121);
    try {
      if (!windowClass) {
        console.info('Failed to load the content. Cause: windowClass is null');
      }
      else {
        (windowClass as window.Window).loadContent('pages/page2', storage, (err: BusinessError) => {
          const errCode: number = err.code;
          if (errCode) {
            console.error('Failed to load the content. Cause:' + JSON.stringify(err));
            return;
          }
          console.info('Succeeded in loading the content.');
        });
      }
    } catch (exception) {
      console.error('Failed to load the content. Cause:' + JSON.stringify(exception));
    }
  }
};

loadContent⁹⁺

loadContent(path: string, storage: LocalStorage): Promise<void>

Loads the content of a page, with its path in the current project specified, to this window, and transfers the state attribute to the page through a local storage. This API uses a promise to return the result.

Model restriction: This API can be used only in the stage model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { BusinessError } from '@ohos.base';

export default class EntryAbility extends UIAbility {
  // ...

  onWindowStageCreate(windowStage: window.WindowStage) {
    console.info('onWindowStageCreate');
    let storage: LocalStorage = new LocalStorage();
    storage.setOrCreate('storageSimpleProp', 121);
    try {
      if (!windowClass) {
        console.info('Failed to load the content. Cause: windowClass is null');
      }
      else {
        let promise = (windowClass as window.Window).loadContent('pages/page2', storage);
        promise.then(() => {
          console.info('Succeeded in loading the content.');
        }).catch((err: BusinessError) => {
          console.error('Failed to load the content. Cause:' + JSON.stringify(err));
        });
      }
    } catch (exception) {
      console.error('Failed to load the content. Cause:' + JSON.stringify(exception));
    }
  }
};

loadContentByName¹¹⁺

loadContentByName(name: string, storage: LocalStorage, callback: AsyncCallback<void>): void

Loads the content of a named route page to this window, and transfers the state attribute to the page through a local storage. This API uses an asynchronous callback to return the result.

Model restriction: This API can be used only in the stage model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

// ets/entryability/EntryAbility.ets
import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { BusinessError } from '@ohos.base';
import * as Index from '../pages/Index'; // Import the named route page.

export default class EntryAbility extends UIAbility {
  // ...

  onWindowStageCreate(windowStage: window.WindowStage) {
    console.info('onWindowStageCreate');
    let windowClass: window.Window = windowStage.getMainWindowSync(); // Obtain the main window of the application.
    let storage: LocalStorage = new LocalStorage();
    storage.setOrCreate('storageSimpleProp', 121);
    try {
      if (!windowClass) {
        console.info('Failed to load the content. Cause: windowClass is null');
      } else {
        (windowClass as window.Window).loadContentByName(Index.entryName, storage, (err: BusinessError) => {
          const errCode: number = err.code;
          if (errCode) {
            console.error('Failed to load the content. Cause:' + JSON.stringify(err));
            return;
          }
          console.info('Succeeded in loading the content.');
        });
      }
    } catch (exception) {
      console.error('Failed to load the content. Cause:' + JSON.stringify(exception));
    }
  }
};

// ets/pages/Index.ets
export const entryName : string = 'Index';
@Entry({routeName: entryName, storage : LocalStorage.getShared()})
@Component
export struct Index {
  @State message: string = 'Hello World'
  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
      }
      .width('100%')
    }
    .height('100%')
  }
}

loadContentByName¹¹⁺

loadContentByName(name: string, callback: AsyncCallback<void>): void

Loads the content of a named route page to this window. This API uses an asynchronous callback to return the result.

Model restriction: This API can be used only in the stage model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

// ets/entryability/EntryAbility.ets
import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { BusinessError } from '@ohos.base';
import * as Index from '../pages/Index'; // Import the named route page.

export default class EntryAbility extends UIAbility {
  // ...

  onWindowStageCreate(windowStage: window.WindowStage) {
    console.info('onWindowStageCreate');
    let windowClass: window.Window = windowStage.getMainWindowSync(); // Obtain the main window of the application.
    try {
      if (!windowClass) {
        console.info('Failed to load the content. Cause: windowClass is null');
      } else {
        (windowClass as window.Window).loadContentByName(Index.entryName, (err: BusinessError) => {
          const errCode: number = err.code;
          if (errCode) {
            console.error('Failed to load the content. Cause:' + JSON.stringify(err));
            return;
          }
          console.info('Succeeded in loading the content.');
        });
      }
    } catch (exception) {
      console.error('Failed to load the content. Cause:' + JSON.stringify(exception));
    }
  }
};

// ets/pages/Index.ets
export const entryName : string = 'Index';
@Entry({routeName: entryName})
@Component
export struct Index {
  @State message: string = 'Hello World'
  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
      }
      .width('100%')
    }
    .height('100%')
  }
}

loadContentByName¹¹⁺

loadContentByName(name: string, storage?: LocalStorage): Promise<void>

Loads the content of a named route page to this window, and transfers the state attribute to the page through a local storage. This API uses a promise to return the result.

Model restriction: This API can be used only in the stage model.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

// ets/entryability/EntryAbility.ets
import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { BusinessError } from '@ohos.base';
import * as Index from '../pages/Index'; // Import the named route page.

export default class EntryAbility extends UIAbility {
  // ...

  onWindowStageCreate(windowStage: window.WindowStage) {
    console.info('onWindowStageCreate');
    let windowClass: window.Window = windowStage.getMainWindowSync(); // Obtain the main window of the application.
    let storage: LocalStorage = new LocalStorage();
    storage.setOrCreate('storageSimpleProp', 121);
    try {
      if (!windowClass) {
        console.info('Failed to load the content. Cause: windowClass is null');
      } else {
        let promise = (windowClass as window.Window).loadContentByName(Index.entryName, storage);
        promise.then(() => {
          console.info('Succeeded in loading the content.');
        }).catch((err: BusinessError) => {
          console.error('Failed to load the content. Cause:' + JSON.stringify(err));
        });
      }
    } catch (exception) {
      console.error('Failed to load the content. Cause:' + JSON.stringify(exception));
    }
  }
};

// ets/pages/Index.ets
export const entryName : string = 'Index';
@Entry({routeName: entryName, storage : LocalStorage.getShared()})
@Component
export struct Index {
  @State message: string = 'Hello World'
  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
      }
      .width('100%')
    }
    .height('100%')
  }
}

isWindowShowing⁹⁺

isWindowShowing(): boolean

Checks whether this window is displayed.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  let data = windowClass.isWindowShowing();
  console.info('Succeeded in checking whether the window is showing. Data: ' + JSON.stringify(data));
} catch (exception) {
  console.error('Failed to check whether the window is showing. Cause: ' + JSON.stringify(exception));
}

on('windowSizeChange')⁷⁺

on(type: 'windowSizeChange', callback: Callback<Size>): void

Subscribes to the window size change event.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.on('windowSizeChange', (data) => {
    console.info('Succeeded in enabling the listener for window size changes. Data: ' + JSON.stringify(data));
  });
} catch (exception) {
  console.error('Failed to enable the listener for window size changes. Cause: ' + JSON.stringify(exception));
}

off('windowSizeChange')⁷⁺

off(type: 'windowSizeChange', callback?: Callback<Size>): void

Unsubscribes from the window size change event.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.off('windowSizeChange');
} catch (exception) {
  console.error('Failed to disable the listener for window size changes. Cause: ' + JSON.stringify(exception));
}

on('avoidAreaChange')⁹⁺

on(type: 'avoidAreaChange', callback: Callback<{ type: AvoidAreaType, area: AvoidArea}>): void

Subscribes to the event indicating changes to the area where the window cannot be displayed.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.on('avoidAreaChange', (data) => {
    console.info('Succeeded in enabling the listener for system avoid area changes. type:' +
    JSON.stringify(data.type) + ', area: ' + JSON.stringify(data.area));
  });
} catch (exception) {
  console.error('Failed to enable the listener for system avoid area changes. Cause: ' + JSON.stringify(exception));
}

off('avoidAreaChange')⁹⁺

off(type: 'avoidAreaChange', callback?: Callback<{ type: AvoidAreaType, area: AvoidArea }>): void

Unsubscribes from the event indicating changes to the area where the window cannot be displayed.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.off('avoidAreaChange');
} catch (exception) {
  console.error('Failed to disable the listener for system avoid area changes. Cause: ' + JSON.stringify(exception));
}

on('keyboardHeightChange')⁷⁺

on(type: 'keyboardHeightChange', callback: Callback<number>): void

Subscribes to the event indicating soft keyboard height changes in the input method panel in fixed state. Since API version 10, the input method panel can be set to the fixed or floating state. For details, see Input Method Service.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.on('keyboardHeightChange', (data) => {
    console.info('Succeeded in enabling the listener for keyboard height changes. Data: ' + JSON.stringify(data));
  });
} catch (exception) {
  console.error('Failed to enable the listener for keyboard height changes. Cause: ' + JSON.stringify(exception));
}

off('keyboardHeightChange')⁷⁺

off(type: 'keyboardHeightChange', callback?: Callback<number>): void

Unsubscribes from the event indicating soft keyboard height changes in the input method panel in fixed state. Since API version 10, the input method panel can be set to the fixed or floating state. For details, see Input Method Service.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.off('keyboardHeightChange');
} catch (exception) {
  console.error('Failed to disable the listener for keyboard height changes. Cause: ' + JSON.stringify(exception));
}

on('touchOutside')¹¹⁺

on(type: 'touchOutside', callback: Callback<void>): void

Subscribes to the touch event outside this window.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.on('touchOutside', () => {
    console.info('touch outside');
  });
} catch (exception) {
  console.error('Failed to register callback. Cause: ' + JSON.stringify(exception));
}

off('touchOutside')¹¹⁺

off(type: 'touchOutside', callback?: Callback<void>): void

Unsubscribes from the touch event outside this window.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.off('touchOutside');
} catch (exception) {
  console.error('Failed to unregister callback. Cause: ' + JSON.stringify(exception));
}

on('screenshot')⁹⁺

on(type: 'screenshot', callback: Callback<void>): void

Subscribes to the screenshot event.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.on('screenshot', () => {
    console.info('screenshot happened');
  });
} catch (exception) {
  console.error('Failed to register callback. Cause: ' + JSON.stringify(exception));
}

off('screenshot')⁹⁺

off(type: 'screenshot', callback?: Callback<void>): void

Unsubscribes from the screenshot event.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

let callback = () => {
  console.info('screenshot happened');
};
try {
  windowClass.on('screenshot', callback);
} catch (exception) {
  console.error('Failed to register callback. Cause: ' + JSON.stringify(exception));
}
try {
  windowClass.off('screenshot', callback);
  // If multiple callbacks are enabled in on(), they will all be disabled.
  windowClass.off('screenshot');
} catch (exception) {
  console.error('Failed to unregister callback. Cause: ' + JSON.stringify(exception));
}

on('dialogTargetTouch')¹⁰⁺

on(type: 'dialogTargetTouch', callback: Callback<void>): void

Subscribes to the touch event of the target window in the modal window mode.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.on('dialogTargetTouch', () => {
    console.info('touch dialog target');
  });
} catch (exception) {
  console.error('Failed to register callback. Cause: ' + JSON.stringify(exception));
}

off('dialogTargetTouch')¹⁰⁺

off(type: 'dialogTargetTouch', callback?: Callback<void>): void

Unsubscribes from the touch event of the target window in the modal window mode.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.off('dialogTargetTouch');
} catch (exception) {
  console.error('Failed to unregister callback. Cause: ' + JSON.stringify(exception));
}

on('windowEvent')¹⁰⁺

on(type: 'windowEvent', callback: Callback<WindowEventType>): void

Subscribes to the window lifecycle change event.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.on('windowEvent', (data) => {
    console.info('Window event happened. Event:' + JSON.stringify(data));
  });
} catch (exception) {
  console.error('Failed to register callback. Cause: ' + JSON.stringify(exception));
}

off('windowEvent')¹⁰⁺

off(type: 'windowEvent', callback?: Callback<WindowEventType >): void

Unsubscribes from the window lifecycle change event.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

try {
  windowClass.off('windowEvent');
} catch (exception) {
  console.error('Failed to unregister callback. Cause: ' + JSON.stringify(exception));
}

on('windowVisibilityChange')¹¹⁺

on(type: 'windowVisibilityChange', callback: Callback<boolean>): void

Subscribes to the visibility status change event of this window.

System capability: SystemCapability.Window.SessionManager

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  windowClass.on('windowVisibilityChange', (boolean) => {
    console.info('Window visibility changed, isVisible=' + boolean);
  });
} catch (exception) {
  console.error('Failed to register callback. Cause: ' + JSON.stringify(exception));
}

off('windowVisibilityChange')¹¹⁺

off(type: 'windowVisibilityChange', callback?: Callback<boolean>): void

Unsubscribes from the visibility status change event of this window.

System capability: SystemCapability.Window.SessionManager

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  windowClass.off('windowVisibilityChange');
} catch (exception) {
  console.error('Failed to unregister callback. Cause: ' + JSON.stringify(exception));
}

on('windowStatusChange')¹¹⁺

on(type: 'windowStatusChange', callback: Callback<WindowStatusType>): void

Subscribes to the window status change event.

System capability: SystemCapability.Window.SessionManager

Parameters

Example

try {
  windowClass.on('windowStatusChange', (WindowStatusType) => {
    console.info('Succeeded in enabling the listener for window status changes. Data: ' + JSON.stringify(WindowStatusType));
  });
} catch (exception) {
  console.error('Failed to enable the listener for window status changes. Cause: ' + JSON.stringify(exception));
}

off('windowStatusChange')¹¹⁺

off(type: 'windowStatusChange', callback?: Callback<WindowStatusType>): void

Unsubscribes from the window status change event.

System capability: SystemCapability.Window.SessionManager

Parameters

Example

try {
  windowClass.off('windowStatusChange');
} catch (exception) {
  console.error('Failed to disable the listener for window status changes. Cause: ' + JSON.stringify(exception));
}

on('windowTitleButtonRectChange')¹¹⁺

on(type: 'windowTitleButtonRectChange', callback: Callback<TitleButtonRect>): void

Subscribes to the change event of the rectangle that holds the minimize, maximize, and close buttons on the title bar.

System capability: SystemCapability.Window.SessionManager

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  windowClass.on('windowTitleButtonRectChange', (titleButtonRect) => {
    console.info('Succeeded in enabling the listener for window title buttons area changes. Data: ' + JSON.stringify(titleButtonRect));
  });
} catch (exception) {
  console.error('Failed to enable the listener for window title buttons area changes. Cause: ' + JSON.stringify(exception));
}

off('windowTitleButtonRectChange')¹¹⁺

off(type: 'windowTitleButtonRectChange', callback?: Callback<TitleButtonRect>): void

Unsubscribes from the change event of the rectangle that holds the minimize, maximize, and close buttons on the title bar.

System capability: SystemCapability.Window.SessionManager

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  windowClass.off('windowTitleButtonRectChange');
} catch (exception) {
  console.error('Failed to disable the listener for window title buttons area changes. Cause: ' + JSON.stringify(exception));
}

isWindowSupportWideGamut⁹⁺

isWindowSupportWideGamut(callback: AsyncCallback<boolean>): void

Checks whether this window supports the wide-gamut color space. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

windowClass.isWindowSupportWideGamut((err: BusinessError, data) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to check whether the window support WideGamut. Cause:' + JSON.stringify(err));
    return;
  }
  console.info('Succeeded in checking whether the window support WideGamut Data: ' + JSON.stringify(data));
});

isWindowSupportWideGamut⁹⁺

isWindowSupportWideGamut(): Promise<boolean>

Checks whether this window supports the wide-gamut color space. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let promise = windowClass.isWindowSupportWideGamut();
promise.then((data) => {
  console.info('Succeeded in checking whether the window support WideGamut. Data: ' + JSON.stringify(data));
}).catch((err: BusinessError) => {
  console.error('Failed to check whether the window support WideGamut. Cause: ' + JSON.stringify(err));
});

setWindowColorSpace⁹⁺

setWindowColorSpace(colorSpace:ColorSpace, callback: AsyncCallback<void>): void

Sets a color space for this window. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  windowClass.setWindowColorSpace(window.ColorSpace.WIDE_GAMUT, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set window colorspace. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting window colorspace.');
  });
} catch (exception) {
  console.error('Failed to set window colorspace. Cause:' + JSON.stringify(exception));
}

setWindowColorSpace⁹⁺

setWindowColorSpace(colorSpace:ColorSpace): Promise<void>

Sets a color space for this window. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let promise = windowClass.setWindowColorSpace(window.ColorSpace.WIDE_GAMUT);
  promise.then(() => {
    console.info('Succeeded in setting window colorspace.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set window colorspace. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set window colorspace. Cause:' + JSON.stringify(exception));
}

getWindowColorSpace⁹⁺

getWindowColorSpace(): ColorSpace

Obtains the color space of this window.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

let colorSpace = windowClass.getWindowColorSpace();

setWindowBackgroundColor⁹⁺

setWindowBackgroundColor(color: string): void

Sets the background color for this window. In the stage model, this API must be used after the call of loadContent or setUIContent() takes effect.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

private SetUIContent(windowClass: window.Window) {
  windowClass.setUIContent("pages/ButtonWindow",(err: BusinessError) => {
    if (err.code) {
      console.error('Failed to load the content. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in loading the content.');
    let color: string = '#00ff33';
    try {
      windowClass.setWindowBackgroundColor(color);
    } catch (exception) {
      console.error('Failed to set the background color. Cause: ' + JSON.stringify(exception));
    };
  });
}

setWindowBrightness⁹⁺

setWindowBrightness(brightness: number, callback: AsyncCallback<void>): void

Called by the application window to set the screen brightness. This API uses an asynchronous callback to return the result.

When the screen brightness setting for the window takes effect, Control Panel cannot adjust the system screen brightness. It can do so only after the window screen brightness is restored to the default value.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let brightness: number = 1;
try {
  windowClass.setWindowBrightness(brightness, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the brightness. Cause: ' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the brightness.');
  });
} catch (exception) {
  console.error('Failed to set the brightness. Cause: ' + JSON.stringify(exception));
}

setWindowBrightness⁹⁺

setWindowBrightness(brightness: number): Promise<void>

Called by the application window to set the screen brightness. This API uses a promise to return the result.

When the screen brightness setting for the window takes effect, Control Panel cannot adjust the system screen brightness. It can do so only after the window screen brightness is restored to the default value.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let brightness: number = 1;
try {
  let promise = windowClass.setWindowBrightness(brightness);
  promise.then(() => {
    console.info('Succeeded in setting the brightness.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the brightness. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the brightness. Cause: ' + JSON.stringify(exception));
}

setWindowFocusable⁹⁺

setWindowFocusable(isFocusable: boolean, callback: AsyncCallback<void>): void

Sets whether this window can gain focus. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isFocusable: boolean = true;
try {
  windowClass.setWindowFocusable(isFocusable, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the window to be focusable. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the window to be focusable.');
  });
} catch (exception) {
  console.error('Failed to set the window to be focusable. Cause:' + JSON.stringify(exception));
}

setWindowFocusable⁹⁺

setWindowFocusable(isFocusable: boolean): Promise<void>

Sets whether this window can gain focus. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isFocusable: boolean = true;
try {
  let promise = windowClass.setWindowFocusable(isFocusable);
  promise.then(() => {
    console.info('Succeeded in setting the window to be focusable.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the window to be focusable. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the window to be focusable. Cause:' + JSON.stringify(exception));
}

setWindowKeepScreenOn⁹⁺

setWindowKeepScreenOn(isKeepScreenOn: boolean, callback: AsyncCallback<void>): void

Sets whether to keep the screen always on. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isKeepScreenOn: boolean = true;
try {
  windowClass.setWindowKeepScreenOn(isKeepScreenOn, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the screen to be always on. Cause: ' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the screen to be always on.');
  });
} catch (exception) {
  console.error('Failed to set the screen to be always on. Cause: ' + JSON.stringify(exception));
}

setWindowKeepScreenOn⁹⁺

setWindowKeepScreenOn(isKeepScreenOn: boolean): Promise<void>

Sets whether to keep the screen always on. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isKeepScreenOn: boolean = true;
try {
  let promise = windowClass.setWindowKeepScreenOn(isKeepScreenOn);
  promise.then(() => {
    console.info('Succeeded in setting the screen to be always on.');
  }).catch((err: BusinessError) => {
    console.info('Failed to set the screen to be always on. Cause:  ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the screen to be always on. Cause: ' + JSON.stringify(exception));
}

setWindowPrivacyMode⁹⁺

setWindowPrivacyMode(isPrivacyMode: boolean, callback: AsyncCallback<void>): void

Sets whether this window is in privacy mode. This API uses an asynchronous callback to return the result.

A window in privacy mode cannot be captured or recorded. This API can be used in scenarios where screen capture or recording is disabled.

System capability: SystemCapability.WindowManager.WindowManager.Core

Required permissions: ohos.permission.PRIVACY_WINDOW

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isPrivacyMode: boolean = true;
try {
  windowClass.setWindowPrivacyMode(isPrivacyMode, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the window to privacy mode. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the window to privacy mode.');
  });
} catch (exception) {
  console.error('Failed to set the window to privacy mode. Cause:' + JSON.stringify(exception));
}

setWindowPrivacyMode⁹⁺

setWindowPrivacyMode(isPrivacyMode: boolean): Promise<void>

Sets whether this window is in privacy mode. This API uses a promise to return the result.

A window in privacy mode cannot be captured or recorded. This API can be used in scenarios where screen capture or recording is disabled.

System capability: SystemCapability.WindowManager.WindowManager.Core

Required permissions: ohos.permission.PRIVACY_WINDOW

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isPrivacyMode: boolean = true;
try {
  let promise = windowClass.setWindowPrivacyMode(isPrivacyMode);
  promise.then(() => {
    console.info('Succeeded in setting the window to privacy mode.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the window to privacy mode. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the window to privacy mode. Cause:' + JSON.stringify(exception));
}

setWindowTouchable⁹⁺

setWindowTouchable(isTouchable: boolean, callback: AsyncCallback<void>): void

Sets whether this window is touchable. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isTouchable = true;
try {
  windowClass.setWindowTouchable(isTouchable, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the window to be touchable. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the window to be touchable.');
  });
} catch (exception) {
  console.error('Failed to set the window to be touchable. Cause:' + JSON.stringify(exception));
}

setWindowTouchable⁹⁺

setWindowTouchable(isTouchable: boolean): Promise<void>

Sets whether this window is touchable. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let isTouchable: boolean = true;
try {
  let promise = windowClass.setWindowTouchable(isTouchable);
  promise.then(() => {
    console.info('Succeeded in setting the window to be touchable.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the window to be touchable. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the window to be touchable. Cause:' + JSON.stringify(exception));
}

snapshot⁹⁺

snapshot(callback: AsyncCallback<image.PixelMap>): void

Captures this window. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';
import image from '@ohos.multimedia.image';

windowClass.snapshot((err: BusinessError, pixelMap: image.PixelMap) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to snapshot window. Cause:' + JSON.stringify(err));
    return;
  }
  console.info('Succeeded in snapshotting window. Pixel bytes number: ' + pixelMap.getPixelBytesNumber());
  pixelMap.release(); // Release the memory in time after the PixelMap is used.
});

snapshot⁹⁺

snapshot(): Promise<image.PixelMap>

Captures this window. This API uses a promise to return the result.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';
import image from '@ohos.multimedia.image';

let promise = windowClass.snapshot();
promise.then((pixelMap: image.PixelMap) => {
  console.info('Succeeded in snapshotting window. Pixel bytes number: ' + pixelMap.getPixelBytesNumber());
  pixelMap.release(); // Release the memory in time after the PixelMap is used.
}).catch((err: BusinessError) => {
  console.error('Failed to snapshot window. Cause:' + JSON.stringify(err));
});

setAspectRatio¹⁰⁺

setAspectRatio(ratio: number): Promise<void>

Sets the aspect ratio of the window content layout. This API uses a promise to return the result.

This API is available only for the main window of the application. The aspect ratio will be saved permanently and takes effect even after the application is closed or the device is restarted.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let ratio = 1.0;
  let promise = windowClass.setAspectRatio(ratio);
  promise.then(() => {
    console.info('Succeeded in setting aspect ratio of window.');
  }).catch((err: BusinessError) => {
    console.error('Failed to set the aspect ratio of window. Cause:' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to set the aspect ratio of window. Cause: ' + JSON.stringify(exception));
}

setAspectRatio¹⁰⁺

setAspectRatio(ratio: number, callback: AsyncCallback<void>): void

Sets the aspect ratio of the window content layout. This API uses an asynchronous callback to return the result.

This API is available only for the main window of the application. The aspect ratio will be saved permanently and takes effect even after the application is closed or the device is restarted.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let ratio = 1.0;
  windowClass.setAspectRatio(ratio, (err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to set the aspect ratio of window. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in setting the aspect ratio of window.');
  });
} catch (exception) {
  console.error('Failed to set the aspect ratio of window. Cause: ' + JSON.stringify(exception));
}

resetAspectRatio¹⁰⁺

resetAspectRatio(): Promise<void>

Resets the aspect ratio of the window content layout. This API uses a promise to return the result.

This API is available only for the main window of the application. After this API is called, the persistently stored aspect ratio is cleared.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let promise = windowClass.resetAspectRatio();
  promise.then(() => {
    console.info('Succeeded in resetting aspect ratio of window.');
  }).catch((err: BusinessError) => {
    console.error('Failed to reset the aspect ratio of window. Cause:' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to reset the aspect ratio of window. Cause: ' + JSON.stringify(exception));
}

resetAspectRatio¹⁰⁺

resetAspectRatio(callback: AsyncCallback<void>): void

Resets the aspect ratio of the window content layout. This API uses an asynchronous callback to return the result.

This API is available only for the main window of the application. After this API is called, the persistently stored aspect ratio is cleared.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  windowClass.resetAspectRatio((err: BusinessError) => {
    const errCode: number = err.code;
    if (errCode) {
      console.error('Failed to reset the aspect ratio of window. Cause:' + JSON.stringify(err));
      return;
    }
    console.info('Succeeded in resetting aspect ratio of window.');
  });
} catch (exception) {
  console.error('Failed to reset the aspect ratio of window. Cause: ' + JSON.stringify(exception));
}

minimize¹¹⁺

minimize(callback: AsyncCallback<void>): void

Implements different functionalities based on the caller:

Minimizes the main window if the caller is the main window. The main window can be restored in the dock bar.

Hides the subwindow if the caller is a subwindow. The subwindow cannot be restored in the dock bar.

This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Window.SessionManager

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

windowClass.minimize((err: BusinessError) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to minimize the window. Cause: ' + JSON.stringify(err));
    return;
  }
  console.info('Succeeded in minimizing the window.');
});

minimize¹¹⁺

minimize(): Promise<void>

Implements different functionalities based on the caller:

Minimizes the main window if the caller is the main window. The main window can be restored in the dock bar.

Hides the subwindow if the caller is a subwindow. The subwindow cannot be restored in the dock bar.

This API uses a promise to return the result.

System capability: SystemCapability.Window.SessionManager

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let promise = windowClass.minimize();
promise.then(() => {
  console.info('Succeeded in minimizing the window.');
}).catch((err: BusinessError) => {
  console.error('Failed to minimize the window. Cause: ' + JSON.stringify(err));
});

recover¹¹⁺

recover(): Promise<void>

Restores the main window from the full-screen, maximized, or split-screen mode to a floating window, and restores the window size and position to those before the full-screen, maximized, or split-screen mode is entered. If the main window is already in the floating window mode, nothing will happen. This API uses a promise to return the result. It takes effect only for certain device types.

System capability: SystemCapability.Window.SessionManager

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';

let promise = windowClass.recover();
promise.then(() => {
  console.info('Succeeded in recovering the window.');
}).catch((err: BusinessError) => {
  console.error('Failed to recover the window. Cause: ' + JSON.stringify(err));
});

getWindowLimits¹¹⁺

getWindowLimits(): WindowLimits

Obtains the size limits of this window.

System capability: SystemCapability.Window.SessionManager

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  let windowLimits = windowClass.getWindowLimits();
} catch (exception) {
  console.error('Failed to obtain the window limits of window. Cause: ' + JSON.stringify(exception));
}

setWindowLimits¹¹⁺

setWindowLimits(windowLimits: WindowLimits): Promise<WindowLimits>

Sets the size limits for this window. This API uses a promise to return the result.

System capability: SystemCapability.Window.SessionManager

Parameters

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

import { BusinessError } from '@ohos.base';
try {
  let windowLimits: window.WindowLimits = {
    maxWidth: 1500,
    maxHeight: 1000,
    minWidth: 500,
    minHeight: 400
  };
  let promise = windowClass.setWindowLimits(windowLimits);
    promise.then((data) => {
    console.info('Succeeded in changing the window limits. Cause:' + JSON.stringify(data));
  }).catch((err: BusinessError) => {
    console.error('Failed to change the window limits. Cause: ' + JSON.stringify(err));
  });
} catch (exception) {
  console.error('Failed to change the window limits. Cause:' + JSON.stringify(exception));
}

keepKeyboardOnFocus¹¹⁺

keepKeyboardOnFocus(keepKeyboardFlag: boolean): void

Sets whether to keep the soft keyboard created by others when a window has focus. This API can be called only by a system window or an application subwindow.

System capability: SystemCapability.Window.SessionManager

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  windowClass.keepKeyboardOnFocus(true);
} catch (exception) {
  console.error('Failed to keep keyboard onFocus. Cause: ' + JSON.stringify(exception));
}

setWindowDecorVisible¹¹⁺

setWindowDecorVisible(isVisible: boolean): void

Sets whether the title bar is visible in the main window.

System capability: SystemCapability.Window.SessionManager

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

import UIAbility from '@ohos.app.ability.UIAbility';
import { BusinessError } from '@ohos.base';

export default class EntryAbility extends UIAbility {
  onWindowStageCreate(windowStage: window.WindowStage) {
    // Load content for the main window.
    windowStage.loadContent("pages/page2", (err: BusinessError) => {
      let errCode: number = err.code;
      if (errCode) {
        console.error('Failed to load the content. Cause:' + JSON.stringify(err));
        return;
      }
      console.info('Succeeded in loading the content.');
      // Obtain the main window.
      let mainWindow: window.Window | undefined = undefined;
      windowStage.getMainWindow((err: BusinessError, data) => {
        let errCode: number = err.code;
        if (errCode) {
          console.error('Failed to obtain the main window. Cause: ' + JSON.stringify(err));
          return;
        }
        mainWindow = data;
        console.info('Succeeded in obtaining the main window. Data: ' + JSON.stringify(data));
        let isVisible = false;
        // Call setWindowDecorVisible.
        try {
          mainWindow.setWindowDecorVisible(isVisible);
        } catch (exception) {
          console.error('Failed to set the visibility of window decor. Cause: ' + JSON.stringify(exception));
        }
      })
    });
  }
};

setWindowDecorHeight¹¹⁺

setWindowDecorHeight(height: number): void

Sets the height of the title bar for this window.

System capability: SystemCapability.Window.SessionManager

Parameters

Error codes

For details about the error codes, see Window Error Codes.

Example

let height: number = 50;
try {
  windowClass.setWindowDecorHeight(height);
} catch (exception) {
  console.error('Failed to set the height of window decor. Cause: ' + JSON.stringify(exception));
}

getWindowDecorHeight¹¹⁺

getWindowDecorHeight(): number

Obtains the height of the title bar of this window.

System capability: SystemCapability.Window.SessionManager

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  let height = windowClass.getWindowDecorHeight();
} catch (exception) {
  console.error('Failed to get the height of window decor. Cause: ' + JSON.stringify(exception));
}

getTitleButtonRect¹¹⁺

getTitleButtonRect(): TitleButtonRect

Obtains the rectangle that holds the minimize, maximize, and close buttons on the title bar.

System capability: SystemCapability.Window.SessionManager

Return value

Error codes

For details about the error codes, see Window Error Codes.

Example

try {
  let titleButtonArea = windowClass.getTitleButtonRect();
  console.info('Succeeded in obtaining the area of title buttons. Data: ' + JSON.stringify(titleButtonArea));
} catch (exception) {
  console.error('Failed to get the area of title buttons. Cause: ' + JSON.stringify(exception));
}

show^(deprecated)

show(callback: AsyncCallback<void>): void

Shows this window. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use showWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

windowClass.show((err: BusinessError) => {
  const errCode: number = err.code;
  if (errCode) {
    console.error('Failed to show the window. Cause: ' + JSON.stringify(err));
    return;
  }
  console.info('Succeeded in showing the window.');
});

show^(deprecated)

show(): Promise<void>

Shows this window. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use showWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Return value

Example

import { BusinessError } from '@ohos.base';

let promise = windowClass.show();
promise.then(() => {
  console.info('Succeeded in showing the window.');
}).catch((err: BusinessError) => {
  console.error('Failed to show the window. Cause: ' + JSON.stringify(err));
});

destroy^(deprecated)

destroy(callback: AsyncCallback<void>): void

Destroys this window. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use destroyWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

windowClass.destroy((err: BusinessError) => {
  const errCode: number = err.code;
  if (err.code) {
    console.error('Failed to destroy the window. Cause:' + JSON.stringify(err));
    return;
  }
  console.info('Succeeded in destroying the window.');
});

destroy^(deprecated)

destroy(): Promise<void>

Destroys this window. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use destroyWindow() instead.

System capability: SystemCapability.WindowManager.WindowManager.Core