2017-07-18 01:13:04 +00:00
|
|
|
/**
|
|
|
|
* Copyright 2017 Google Inc. All rights reserved.
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
2023-02-15 23:09:31 +00:00
|
|
|
import {Protocol} from 'devtools-protocol';
|
|
|
|
|
2023-06-15 12:30:37 +00:00
|
|
|
import {GeolocationOptions, MediaFeature} from '../api/Page.js';
|
|
|
|
import {assert} from '../util/assert.js';
|
2023-09-07 08:05:57 +00:00
|
|
|
import {invokeAtMostOnceForArguments} from '../util/decorators.js';
|
2023-06-15 12:30:37 +00:00
|
|
|
import {isErrorLike} from '../util/ErrorLike.js';
|
|
|
|
|
2023-08-30 09:04:28 +00:00
|
|
|
import {CDPSession, CDPSessionEmittedEvents} from './Connection.js';
|
2022-06-22 13:25:44 +00:00
|
|
|
import {Viewport} from './PuppeteerViewport.js';
|
2023-09-07 08:05:57 +00:00
|
|
|
import {debugError} from './util.js';
|
|
|
|
|
|
|
|
interface ViewportState {
|
|
|
|
viewport?: Viewport;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface IdleOverridesState {
|
|
|
|
overrides?: {
|
|
|
|
isUserActive: boolean;
|
|
|
|
isScreenUnlocked: boolean;
|
|
|
|
};
|
|
|
|
active: boolean;
|
|
|
|
}
|
2017-07-18 01:13:04 +00:00
|
|
|
|
2023-09-07 09:57:19 +00:00
|
|
|
interface TimezoneState {
|
|
|
|
timezoneId?: string;
|
|
|
|
active: boolean;
|
|
|
|
}
|
|
|
|
|
2022-06-27 07:24:23 +00:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*/
|
2020-04-28 16:45:34 +00:00
|
|
|
export class EmulationManager {
|
2022-06-13 09:16:25 +00:00
|
|
|
#client: CDPSession;
|
|
|
|
#emulatingMobile = false;
|
|
|
|
#hasTouch = false;
|
2023-06-15 12:30:37 +00:00
|
|
|
#javascriptEnabled = true;
|
2020-04-21 08:20:25 +00:00
|
|
|
|
2023-09-07 08:05:57 +00:00
|
|
|
#viewportState: ViewportState = {};
|
|
|
|
#idleOverridesState: IdleOverridesState = {
|
|
|
|
active: false,
|
|
|
|
};
|
2023-09-07 09:57:19 +00:00
|
|
|
#timezoneState: TimezoneState = {
|
|
|
|
active: false,
|
|
|
|
};
|
2023-08-30 09:04:28 +00:00
|
|
|
#secondaryClients = new Set<CDPSession>();
|
|
|
|
|
2020-04-28 16:45:34 +00:00
|
|
|
constructor(client: CDPSession) {
|
2022-06-13 09:16:25 +00:00
|
|
|
this.#client = client;
|
2017-07-30 02:12:17 +00:00
|
|
|
}
|
|
|
|
|
2023-08-28 06:20:57 +00:00
|
|
|
updateClient(client: CDPSession): void {
|
|
|
|
this.#client = client;
|
2023-08-30 09:04:28 +00:00
|
|
|
this.#secondaryClients.delete(client);
|
|
|
|
}
|
|
|
|
|
2023-08-30 13:07:11 +00:00
|
|
|
async registerSpeculativeSession(client: CDPSession): Promise<void> {
|
2023-08-30 09:04:28 +00:00
|
|
|
this.#secondaryClients.add(client);
|
|
|
|
client.once(CDPSessionEmittedEvents.Disconnected, () => {
|
|
|
|
return this.#secondaryClients.delete(client);
|
|
|
|
});
|
2023-09-07 09:57:19 +00:00
|
|
|
// We don't await here because we want to register all state changes before
|
|
|
|
// the target is unpaused.
|
2023-09-07 08:05:57 +00:00
|
|
|
void this.#syncViewport().catch(debugError);
|
|
|
|
void this.#syncIdleState().catch(debugError);
|
2023-09-07 09:57:19 +00:00
|
|
|
void this.#syncTimezoneState().catch(debugError);
|
2023-08-28 06:20:57 +00:00
|
|
|
}
|
|
|
|
|
2023-06-15 12:30:37 +00:00
|
|
|
get javascriptEnabled(): boolean {
|
|
|
|
return this.#javascriptEnabled;
|
|
|
|
}
|
|
|
|
|
2020-05-06 13:23:07 +00:00
|
|
|
async emulateViewport(viewport: Viewport): Promise<boolean> {
|
2023-09-07 08:05:57 +00:00
|
|
|
this.#viewportState = {
|
|
|
|
viewport,
|
|
|
|
};
|
2023-08-30 09:04:28 +00:00
|
|
|
|
2023-09-07 08:05:57 +00:00
|
|
|
await this.#syncViewport();
|
2023-08-30 09:04:28 +00:00
|
|
|
|
|
|
|
const mobile = viewport.isMobile || false;
|
|
|
|
const hasTouch = viewport.hasTouch || false;
|
|
|
|
const reloadNeeded =
|
|
|
|
this.#emulatingMobile !== mobile || this.#hasTouch !== hasTouch;
|
|
|
|
this.#emulatingMobile = mobile;
|
|
|
|
this.#hasTouch = hasTouch;
|
|
|
|
|
|
|
|
return reloadNeeded;
|
|
|
|
}
|
|
|
|
|
2023-09-07 08:05:57 +00:00
|
|
|
async #syncViewport() {
|
|
|
|
await Promise.all([
|
|
|
|
this.#applyViewport(this.#client, this.#viewportState),
|
|
|
|
...Array.from(this.#secondaryClients).map(client => {
|
|
|
|
return this.#applyViewport(client, this.#viewportState);
|
|
|
|
}),
|
|
|
|
]);
|
|
|
|
}
|
|
|
|
|
|
|
|
@invokeAtMostOnceForArguments
|
|
|
|
async #applyViewport(
|
|
|
|
client: CDPSession,
|
|
|
|
viewportState: ViewportState
|
|
|
|
): Promise<void> {
|
|
|
|
if (!viewportState.viewport) {
|
2023-08-30 09:04:28 +00:00
|
|
|
return;
|
|
|
|
}
|
2023-09-07 08:05:57 +00:00
|
|
|
const {viewport} = viewportState;
|
2017-07-18 01:13:04 +00:00
|
|
|
const mobile = viewport.isMobile || false;
|
|
|
|
const width = viewport.width;
|
|
|
|
const height = viewport.height;
|
2023-03-24 09:56:52 +00:00
|
|
|
const deviceScaleFactor = viewport.deviceScaleFactor ?? 1;
|
2021-05-12 14:48:30 +00:00
|
|
|
const screenOrientation: Protocol.Emulation.ScreenOrientation =
|
|
|
|
viewport.isLandscape
|
2022-06-22 13:25:44 +00:00
|
|
|
? {angle: 90, type: 'landscapePrimary'}
|
|
|
|
: {angle: 0, type: 'portraitPrimary'};
|
2018-06-29 01:48:44 +00:00
|
|
|
const hasTouch = viewport.hasTouch || false;
|
2017-07-18 01:13:04 +00:00
|
|
|
|
|
|
|
await Promise.all([
|
2023-08-30 09:04:28 +00:00
|
|
|
client.send('Emulation.setDeviceMetricsOverride', {
|
2020-05-07 10:54:55 +00:00
|
|
|
mobile,
|
|
|
|
width,
|
|
|
|
height,
|
|
|
|
deviceScaleFactor,
|
|
|
|
screenOrientation,
|
|
|
|
}),
|
2023-08-30 09:04:28 +00:00
|
|
|
client.send('Emulation.setTouchEmulationEnabled', {
|
2020-05-07 10:54:55 +00:00
|
|
|
enabled: hasTouch,
|
|
|
|
}),
|
2017-07-18 01:13:04 +00:00
|
|
|
]);
|
|
|
|
}
|
2023-06-15 12:30:37 +00:00
|
|
|
|
|
|
|
async emulateIdleState(overrides?: {
|
|
|
|
isUserActive: boolean;
|
|
|
|
isScreenUnlocked: boolean;
|
|
|
|
}): Promise<void> {
|
2023-09-07 08:05:57 +00:00
|
|
|
this.#idleOverridesState = {
|
|
|
|
active: true,
|
|
|
|
overrides,
|
|
|
|
};
|
|
|
|
await this.#syncIdleState();
|
|
|
|
}
|
|
|
|
|
|
|
|
async #syncIdleState() {
|
|
|
|
await Promise.all([
|
|
|
|
this.#emulateIdleState(this.#client, this.#idleOverridesState),
|
|
|
|
...Array.from(this.#secondaryClients).map(client => {
|
|
|
|
return this.#emulateIdleState(client, this.#idleOverridesState);
|
|
|
|
}),
|
|
|
|
]);
|
|
|
|
}
|
|
|
|
|
|
|
|
@invokeAtMostOnceForArguments
|
|
|
|
async #emulateIdleState(
|
|
|
|
client: CDPSession,
|
|
|
|
idleStateState: IdleOverridesState
|
|
|
|
): Promise<void> {
|
|
|
|
if (!idleStateState.active) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (idleStateState.overrides) {
|
|
|
|
await client.send('Emulation.setIdleOverride', {
|
|
|
|
isUserActive: idleStateState.overrides.isUserActive,
|
|
|
|
isScreenUnlocked: idleStateState.overrides.isScreenUnlocked,
|
2023-06-15 12:30:37 +00:00
|
|
|
});
|
|
|
|
} else {
|
2023-09-07 08:05:57 +00:00
|
|
|
await client.send('Emulation.clearIdleOverride');
|
2023-06-15 12:30:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-09-07 09:57:19 +00:00
|
|
|
async #emulateTimezone(
|
|
|
|
client: CDPSession,
|
|
|
|
timezoneState: TimezoneState
|
|
|
|
): Promise<void> {
|
|
|
|
if (!timezoneState.active) {
|
|
|
|
return;
|
|
|
|
}
|
2023-06-15 12:30:37 +00:00
|
|
|
try {
|
2023-09-07 09:57:19 +00:00
|
|
|
await client.send('Emulation.setTimezoneOverride', {
|
|
|
|
timezoneId: timezoneState.timezoneId || '',
|
2023-06-15 12:30:37 +00:00
|
|
|
});
|
|
|
|
} catch (error) {
|
|
|
|
if (isErrorLike(error) && error.message.includes('Invalid timezone')) {
|
2023-09-07 09:57:19 +00:00
|
|
|
throw new Error(`Invalid timezone ID: ${timezoneState.timezoneId}`);
|
2023-06-15 12:30:37 +00:00
|
|
|
}
|
|
|
|
throw error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-09-07 09:57:19 +00:00
|
|
|
async #syncTimezoneState() {
|
|
|
|
await Promise.all([
|
|
|
|
this.#emulateTimezone(this.#client, this.#timezoneState),
|
|
|
|
...Array.from(this.#secondaryClients).map(client => {
|
|
|
|
return this.#emulateTimezone(client, this.#timezoneState);
|
|
|
|
}),
|
|
|
|
]);
|
|
|
|
}
|
|
|
|
|
|
|
|
async emulateTimezone(timezoneId?: string): Promise<void> {
|
|
|
|
this.#timezoneState = {
|
|
|
|
timezoneId,
|
|
|
|
active: true,
|
|
|
|
};
|
|
|
|
await this.#syncTimezoneState();
|
|
|
|
}
|
|
|
|
|
2023-06-15 12:30:37 +00:00
|
|
|
async emulateVisionDeficiency(
|
|
|
|
type?: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest['type']
|
|
|
|
): Promise<void> {
|
|
|
|
const visionDeficiencies = new Set<
|
|
|
|
Protocol.Emulation.SetEmulatedVisionDeficiencyRequest['type']
|
|
|
|
>([
|
|
|
|
'none',
|
|
|
|
'achromatopsia',
|
|
|
|
'blurredVision',
|
|
|
|
'deuteranopia',
|
|
|
|
'protanopia',
|
|
|
|
'tritanopia',
|
|
|
|
]);
|
|
|
|
try {
|
|
|
|
assert(
|
|
|
|
!type || visionDeficiencies.has(type),
|
|
|
|
`Unsupported vision deficiency: ${type}`
|
|
|
|
);
|
|
|
|
await this.#client.send('Emulation.setEmulatedVisionDeficiency', {
|
|
|
|
type: type || 'none',
|
|
|
|
});
|
|
|
|
} catch (error) {
|
|
|
|
throw error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async emulateCPUThrottling(factor: number | null): Promise<void> {
|
|
|
|
assert(
|
|
|
|
factor === null || factor >= 1,
|
|
|
|
'Throttling rate should be greater or equal to 1'
|
|
|
|
);
|
|
|
|
await this.#client.send('Emulation.setCPUThrottlingRate', {
|
|
|
|
rate: factor ?? 1,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
async emulateMediaFeatures(features?: MediaFeature[]): Promise<void> {
|
|
|
|
if (!features) {
|
|
|
|
await this.#client.send('Emulation.setEmulatedMedia', {});
|
|
|
|
}
|
|
|
|
if (Array.isArray(features)) {
|
|
|
|
for (const mediaFeature of features) {
|
|
|
|
const name = mediaFeature.name;
|
|
|
|
assert(
|
|
|
|
/^(?:prefers-(?:color-scheme|reduced-motion)|color-gamut)$/.test(
|
|
|
|
name
|
|
|
|
),
|
|
|
|
'Unsupported media feature: ' + name
|
|
|
|
);
|
|
|
|
}
|
|
|
|
await this.#client.send('Emulation.setEmulatedMedia', {
|
|
|
|
features: features,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async emulateMediaType(type?: string): Promise<void> {
|
|
|
|
assert(
|
|
|
|
type === 'screen' ||
|
|
|
|
type === 'print' ||
|
|
|
|
(type ?? undefined) === undefined,
|
|
|
|
'Unsupported media type: ' + type
|
|
|
|
);
|
|
|
|
await this.#client.send('Emulation.setEmulatedMedia', {
|
|
|
|
media: type || '',
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
async setGeolocation(options: GeolocationOptions): Promise<void> {
|
|
|
|
const {longitude, latitude, accuracy = 0} = options;
|
|
|
|
if (longitude < -180 || longitude > 180) {
|
|
|
|
throw new Error(
|
|
|
|
`Invalid longitude "${longitude}": precondition -180 <= LONGITUDE <= 180 failed.`
|
|
|
|
);
|
|
|
|
}
|
|
|
|
if (latitude < -90 || latitude > 90) {
|
|
|
|
throw new Error(
|
|
|
|
`Invalid latitude "${latitude}": precondition -90 <= LATITUDE <= 90 failed.`
|
|
|
|
);
|
|
|
|
}
|
|
|
|
if (accuracy < 0) {
|
|
|
|
throw new Error(
|
|
|
|
`Invalid accuracy "${accuracy}": precondition 0 <= ACCURACY failed.`
|
|
|
|
);
|
|
|
|
}
|
|
|
|
await this.#client.send('Emulation.setGeolocationOverride', {
|
|
|
|
longitude,
|
|
|
|
latitude,
|
|
|
|
accuracy,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Resets default white background
|
|
|
|
*/
|
|
|
|
async resetDefaultBackgroundColor(): Promise<void> {
|
|
|
|
await this.#client.send('Emulation.setDefaultBackgroundColorOverride');
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Hides default white background
|
|
|
|
*/
|
|
|
|
async setTransparentBackgroundColor(): Promise<void> {
|
|
|
|
await this.#client.send('Emulation.setDefaultBackgroundColorOverride', {
|
|
|
|
color: {r: 0, g: 0, b: 0, a: 0},
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
async setJavaScriptEnabled(enabled: boolean): Promise<void> {
|
|
|
|
if (this.#javascriptEnabled === enabled) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
this.#javascriptEnabled = enabled;
|
|
|
|
await this.#client.send('Emulation.setScriptExecutionDisabled', {
|
|
|
|
value: !enabled,
|
|
|
|
});
|
|
|
|
}
|
2017-07-18 01:13:04 +00:00
|
|
|
}
|