ionic-angular

import { EventEmitter, NgZone } from '@angular/core'; export declare type DocumentDirection = 'ltr' | 'rtl'; /** * @name Platform * @description * The Platform service can be used to get information about your current device. * You can get all of the platforms associated with the device using the [platforms](#platforms) * method, including whether the app is being viewed from a tablet, if it's * on a mobile device or browser, and the exact platform (iOS, Android, etc). * You can also get the orientation of the device, if it uses right-to-left * language direction, and much much more. With this information you can completely * customize your app to fit any device. * * @usage * ```ts * import { Platform } from 'ionic-angular'; * * @Component({...}) * export MyPage { * constructor(public platform: Platform) { * * } * } * ``` * @demo /docs/demos/src/platform/ */ export declare class Platform { private _win; private _doc; private _versions; private _dir; private _lang; private _ua; private _qp; private _nPlt; private _readyPromise; private _readyResolve; private _bbActions; private _registry; private _default; private _pW; private _pH; private _lW; private _lH; private _isPortrait; private _uiEvtOpts; /** @hidden */ zone: NgZone; /** @internal */ Css: { transform?: string; transition?: string; transitionDuration?: string; transitionDelay?: string; transitionTimingFn?: string; transitionStart?: string; transitionEnd?: string; transformOrigin?: string; animationDelay?: string; }; /** @internal */ _platforms: string[]; constructor(); /** * @hidden */ setWindow(win: Window): void; /** * @hidden */ win(): Window; /** * @hidden */ setDocument(doc: HTMLDocument): void; /** * @hidden */ doc(): HTMLDocument; /** * @hidden */ setZone(zone: NgZone): void; /** * @hidden */ setCssProps(docElement: HTMLElement): void; /** * @returns {boolean} returns true/false based on platform. * @description * Depending on the platform the user is on, `is(platformName)` will * return `true` or `false`. Note that the same app can return `true` * for more than one platform name. For example, an app running from * an iPad would return `true` for the platform names: `mobile`, * `ios`, `ipad`, and `tablet`. Additionally, if the app was running * from Cordova then `cordova` would be true, and if it was running * from a web browser on the iPad then `mobileweb` would be `true`. * * ``` * import { Platform } from 'ionic-angular'; * * @Component({...}) * export MyPage { * constructor(public platform: Platform) { * if (this.platform.is('ios')) { * // This will only print when on iOS * console.log('I am an iOS device!'); * } * } * } * ``` * * | Platform Name | Description | * |-----------------|------------------------------------| * | android | on a device running Android. | * | cordova | on a device running Cordova. | * | core | on a desktop device. | * | ios | on a device running iOS. | * | ipad | on an iPad device. | * | iphone | on an iPhone device. | * | mobile | on a mobile device. | * | mobileweb | in a browser on a mobile device. | * | phablet | on a phablet device. | * | tablet | on a tablet device. | * | windows | on a device running Windows. | * | electron | in Electron on a desktop device. | * * @param {string} platformName */ is(platformName: string): boolean; /** * @returns {array} the array of platforms * @description * Depending on what device you are on, `platforms` can return multiple values. * Each possible value is a hierarchy of platforms. For example, on an iPhone, * it would return `mobile`, `ios`, and `iphone`. * * ``` * import { Platform } from 'ionic-angular'; * * @Component({...}) * export MyPage { * constructor(public platform: Platform) { * // This will print an array of the current platforms * console.log(this.platform.platforms()); * } * } * ``` */ platforms(): Array<string>; /** * Returns an object containing version information about all of the platforms. * * ``` * import { Platform } from 'ionic-angular'; * * @Component({...}) * export MyPage { * constructor(public platform: Platform) { * // This will print an object containing * // all of the platforms and their versions * console.log(platform.versions()); * } * } * ``` * * @returns {object} An object containing all of the platforms and their versions. */ versions(): { [name: string]: PlatformVersion; }; /** * @hidden */ version(): PlatformVersion; /** * Returns a promise when the platform is ready and native functionality * can be called. If the app is running from within a web browser, then * the promise will resolve when the DOM is ready. When the app is running * from an application engine such as Cordova, then the promise will * resolve when Cordova triggers the `deviceready` event. * * The resolved value is the `readySource`, which states which platform * ready was used. For example, when Cordova is ready, the resolved ready * source is `cordova`. The default ready source value will be `dom`. The * `readySource` is useful if different logic should run depending on the * platform the app is running from. For example, only Cordova can execute * the status bar plugin, so the web should not run status bar plugin logic. * * ``` * import { Component } from '@angular/core'; * import { Platform } from 'ionic-angular'; * * @Component({...}) * export MyApp { * constructor(public platform: Platform) { * this.platform.ready().then((readySource) => { * console.log('Platform ready from', readySource); * // Platform now ready, execute any required native code * }); * } * } * ``` * @returns {promise} */ ready(): Promise<string>; /** * @hidden * This should be triggered by the engine when the platform is * ready. If there was no custom prepareReady method from the engine, * such as Cordova or Electron, then it uses the default DOM ready. */ triggerReady(readySource: string): void; /** * @hidden * This is the default prepareReady if it's not replaced by an engine, * such as Cordova or Electron. If there was no custom prepareReady * method from an engine then it uses the method below, which triggers * the platform ready on the DOM ready event, and the default resolved * value is `dom`. */ prepareReady(): void; /** * Set the app's language direction, which will update the `dir` attribute * on the app's root `<html>` element. We recommend the app's `index.html` * file already has the correct `dir` attribute value set, such as * `<html dir="ltr">` or `<html dir="rtl">`. This method is useful if the * direction needs to be dynamically changed per user/session. * [W3C: Structural markup and right-to-left text in HTML](http://www.w3.org/International/questions/qa-html-dir) * @param {DocumentDirection} dir Examples: `rtl`, `ltr` * @param {boolean} updateDocument */ setDir(dir: DocumentDirection, updateDocument: boolean): void; /** * Returns app's language direction. * We recommend the app's `index.html` file already has the correct `dir` * attribute value set, such as `<html dir="ltr">` or `<html dir="rtl">`. * [W3C: Structural markup and right-to-left text in HTML](http://www.w3.org/International/questions/qa-html-dir) * @returns {DocumentDirection} */ dir(): DocumentDirection; /** * Returns if this app is using right-to-left language direction or not. * We recommend the app's `index.html` file already has the correct `dir` * attribute value set, such as `<html dir="ltr">` or `<html dir="rtl">`. * [W3C: Structural markup and right-to-left text in HTML](http://www.w3.org/International/questions/qa-html-dir) * @returns {boolean} */ isRTL: boolean; /** * Set the app's language and optionally the country code, which will update * the `lang` attribute on the app's root `<html>` element. * We recommend the app's `index.html` file already has the correct `lang` * attribute value set, such as `<html lang="en">`. This method is useful if * the language needs to be dynamically changed per user/session. * [W3C: Declaring language in HTML](http://www.w3.org/International/questions/qa-html-language-declarations) * @param {string} language Examples: `en-US`, `en-GB`, `ar`, `de`, `zh`, `es-MX` * @param {boolean} updateDocument Specifies whether the `lang` attribute of `<html>` should be updated */ setLang(language: string, updateDocument: boolean): void; /** * Returns app's language and optional country code. * We recommend the app's `index.html` file already has the correct `lang` * attribute value set, such as `<html lang="en">`. * [W3C: Declaring language in HTML](http://www.w3.org/International/questions/qa-html-language-declarations) * @returns {string} */ lang(): string; /** * @hidden */ exitApp(): void; /** * @hidden */ backButton: EventEmitter<Event>; /** * The pause event emits when the native platform puts the application * into the background, typically when the user switches to a different * application. This event would emit when a Cordova app is put into * the background, however, it would not fire on a standard web browser. */ pause: EventEmitter<Event>; /** * The resume event emits when the native platform pulls the application * out from the background. This event would emit when a Cordova app comes * out from the background, however, it would not fire on a standard web browser. */ resume: EventEmitter<Event>; /** * The resize event emits when the browser window has changed dimensions. This * could be from a browser window being physically resized, or from a device * changing orientation. */ resize: EventEmitter<Event>; /** * The back button event is triggered when the user presses the native * platform's back button, also referred to as the "hardware" back button. * This event is only used within Cordova apps running on Android and * Windows platforms. This event is not fired on iOS since iOS doesn't come * with a hardware back button in the same sense an Android or Windows device * does. * * Registering a hardware back button action and setting a priority allows * apps to control which action should be called when the hardware back * button is pressed. This method decides which of the registered back button * actions has the highest priority and should be called. * * @param {Function} fn Called when the back button is pressed, * if this registered action has the highest priority. * @param {number} priority Set the priority for this action. Only the highest priority will execute. Defaults to `0`. * @returns {Function} A function that, when called, will unregister * the back button action. */ registerBackButtonAction(fn: Function, priority?: number): Function; /** * @hidden */ runBackButtonAction(): void; /** * @hidden */ setUserAgent(userAgent: string): void; /** * @hidden */ setQueryParams(url: string): void; /** * Get the query string parameter */ getQueryParam(key: string): any; /** * Get the current url. */ url(): string; /** * @hidden */ userAgent(): string; /** * @hidden */ setNavigatorPlatform(navigatorPlt: string): void; /** * @hidden */ navigatorPlatform(): string; /** * Gets the width of the platform's viewport using `window.innerWidth`. * Using this method is preferred since the dimension is a cached value, * which reduces the chance of multiple and expensive DOM reads. */ width(): number; /** * Gets the height of the platform's viewport using `window.innerHeight`. * Using this method is preferred since the dimension is a cached value, * which reduces the chance of multiple and expensive DOM reads. */ height(): number; /** * @hidden */ getElementComputedStyle(ele: HTMLElement, pseudoEle?: string): CSSStyleDeclaration; /** * @hidden */ getElementFromPoint(x: number, y: number): HTMLElement; /** * @hidden */ getElementBoundingClientRect(ele: HTMLElement): ClientRect; /** * Returns `true` if the app is in portait mode. */ isPortrait(): boolean; /** * Returns `true` if the app is in landscape mode. */ isLandscape(): boolean; private _calcDim(); /** * @hidden * This requestAnimationFrame will NOT be wrapped by zone. */ raf(callback: { (timeStamp?: number): void; } | Function): number; /** * @hidden */ cancelRaf(rafId: number): any; /** * @hidden * This setTimeout will NOT be wrapped by zone. */ timeout(callback: Function, timeout?: number): number; /** * @hidden * This setTimeout will NOT be wrapped by zone. */ cancelTimeout(timeoutId: number): void; /** * @hidden * Built to use modern event listener options, like "passive". * If options are not supported, then just return a boolean which * represents "capture". Returns a method to remove the listener. */ registerListener(ele: any, eventName: string, callback: { (ev?: UIEvent): void; }, opts: EventListenerOptions, unregisterListenersCollection?: Function[]): Function; /** * @hidden */ transitionEnd(el: HTMLElement, callback: { (ev?: TransitionEvent): void; }, zone?: boolean): () => void; /** * @hidden */ windowLoad(callback: Function): void; /** * @hidden */ isActiveElement(ele: HTMLElement): boolean; /** * @hidden */ getActiveElement(): Element; /** * @hidden */ hasFocus(ele: HTMLElement): boolean; /** * @hidden */ hasFocusedTextInput(): boolean; /** * @hidden */ focusOutActiveElement(): void; private _initEvents(); /** * @hidden */ setPlatformConfigs(platformConfigs: { [key: string]: PlatformConfig; }): void; /** * @hidden */ getPlatformConfig(platformName: string): PlatformConfig; /** * @hidden */ registry(): { [name: string]: PlatformConfig; }; /** * @hidden */ setDefault(platformName: string): void; /** * @hidden */ testQuery(queryValue: string, queryTestValue: string): boolean; /** * @hidden */ testNavigatorPlatform(navigatorPlatformExpression: string): boolean; /** * @hidden */ matchUserAgentVersion(userAgentExpression: RegExp): any; testUserAgent(expression: string): boolean; /** * @hidden */ isPlatformMatch(queryStringName: string, userAgentAtLeastHas?: string[], userAgentMustNotHave?: string[]): boolean; /** @hidden */ init(): void; /** * @hidden */ private matchPlatform(platformName); } export interface PlatformConfig { isEngine?: boolean; initialize?: Function; isMatch?: Function; superset?: string; subsets?: string[]; settings?: any; versionParser?: any; } export interface PlatformVersion { str?: string; num?: number; major?: number; minor?: number; } export interface EventListenerOptions { capture?: boolean; passive?: boolean; zone?: boolean; } /** * @hidden */ export declare function setupPlatform(doc: HTMLDocument, platformConfigs: { [key: string]: PlatformConfig; }, zone: NgZone): Platform;