github/awesome-cordova-plugins
3
0
Fork 1
mirror of https://github.com/danielsogl/awesome-cordova-plugins.git synced 2026-04-13 00:00:10 +08:00
Code Issues Projects Releases Wiki Activity

chore(): merge v3-injectable into master (#1203)

Browse Source 
* feat(push): plugin is now instance based

no more callbacks

closes #250

* fix(push): fix typo in PushEvents enum

* fix constructor

* feat(push): add subscribe/unsubscribe

fixes #861

* First try

* Moving to modules

* Removed

* Moving things aroudn

* tsconfig for plugins

* Plugin tsconfigs

* Core kind of buidls

* Core

* Plugin tsconfig

* Test

* Remove core

* Build

* Individual packages

* Build and push

* Some stuff

* Bump

* Update core-package.json.template

* Update plugin-package.json.template

* 3.0.0

* Working on injectable

* Updates

* Checkpoint

* More stuff

* Remove duplicate injectables

* Remove lots of static stuff with a fancy regex

* Fix build errors

* chore(): nodejs build script

* chore(): move fs-extra-promise to devDeps

* feat(): make instance based plugins injectable

* Cleanup

* chore(build): convert dependencies to peer dependencies

* chore(build): add auto install scripts (#1059)

* feat(core): auto install scripts

* minor fixes

* minor fixes

* remove prompt message

* fix(plugins): rename packages/classes

* rename google maps

* gulp task to generate readme files

* readme templates

* automating readme file generation and adding it to CI

# Conflicts:
#	src/@ionic-native/plugins/googlemap/index.ts
#	src/@ionic-native/plugins/inappbrowser/index.ts
#	src/@ionic-native/plugins/media/index.ts
#	src/@ionic-native/plugins/sqlite/index.ts

* outputting readmes to dist dir instead of src

* updating package name in usage instructions

* chore(): ngc build

* fix build

* 3.0.1-0

* 3.1.0-alpha.1

* fix AoT support and add publish script

* 3.1.0-alpha.2

* edit publish command

* remove alpha tag

* remove auto-install and cleanup

* 3.1.0-alpha.3

* remove utils from publish command

* refactor(): remove some prefixes

* remove console logs

closes #1145

* chore(): merge master into v3-injectable (#1146)

* 2.5.0

* chore(): update changelog

* fix(pin-dialog): add missing errorIndex

* 2.5.1

* chore(): update changelog

* fix(zip): progress callback is optional (#1049)

* fix(apprate): add missing Windows Store option (#1072)

* Update file-chooser.ts (#1071)

Removed semicolon after .then() in usage instructions

* docs(device-motion): update interface names (#1076)

AccelerationData interface is wrongly named in docs. It should be DeviceMotionAccelerationData. And I added it to import statement.

* feat(inappbrowser): add interface for IAB options (#1065)

* Add InAppBrowserOptions Interface for better tooling.

* feat(inappbrowser): add  interface for IAB options

* Add more constructor tests.

* Add missing iOS options.

* docs(media): update method usage (#1089)

* fix(push): add the missing option clearBadge (#1087)

* docs(badge): fix example (#1096)

Error in code example (supplied parameters do not match call signature)

* fix(imagepicker): add outputType option (#1098)

* fix(facebook): fixes issue when not supplying default params (#1088)

* Fix default facebook logEvent parameters

* Implement correct parameters format in facebook logEvent method

* Update ibeacon.ts (#1099)

Return type of `getAuthorizationStatus()` made more explicit.

* fix(file): add missing exports (#1101)

Any declaration that is not being exported is missing from the resulting d.ts declaration files.

* Add InAppBrowserOptions interface to documentation. (#1103)

* Update sqlite.ts (#1106)

Added a bracket to remove the syntax error

* update device orientation docs to reflect renaming of CompassHeading interface (#1107)

* Move marker code inside MAP_READY (#1108)

The code to set the camera position and marker should be moved inside the function handling MAP_READY.  Otherwise they execute before the event is fired and it doesn't work.

* refactor(file): accept ArrayBuffer for data to write (#1109)

* docs(google-maps): fix param type

closes #1110

* fix(media): add missing pauseRecord and resumeRecord methods (#1122)

* docs(stripe): fix type and naming issues (#1129)

* refactor(paypal): fix type of items (#1125)

Type of items should be Array<PayPalItem> instead of string.

* fix(serial): Serial.requestPermission() options are optional (#1128)

* add success/error indices

* feat(browser-tab): add browser tab plugin (#1126)

* feature: added hasPermission function to Firebase fixes #1115

* feat: Implemented support for BrowserTab #1077

* docs(browser-tab): add proper docs

* fix(background-geolocation): configure returns a promise

closes #1118

* docs(background-geolocation): add return types and platforms

* fix(contacts): allow passing asterisk as contact field type

closes 1093

* fix(contacts): allow passing asterisk as contact field type

closes #1093

* fix(plugin): revert changes to support stable version (#1116)

 fix #1001

* feat(file): add system paths

* feat(app-update): add cordova-plugin-app-update support (#1105)

* add new app-update plugin

* update plugin info

* docs(app-update): add docs

* feat(alipay): add alipay support. (#1097)

* add cordova-alipay-base plugin. to support Alipay payment

* change ALI_PID to APP_ID, make it same with the latest SDK

* rewrite comments

* docs(google-maps): improve docs (#1095)

Move `map.moveCamera(position);` inside the MAP_READY event.
Allow to zoom the map on first launch (both iOS and Android).

* fix(file): remove FileError from return type (#1086)

Promises that reject with a `FileError` are not of the type `Promise<T|FileError>`, but `Promise<T>`.

The previous declarations of `Promise<T|FileError>` would break typing further down the chain where you are trying to use the value that the typing says could be `T|FileError` but in reality could only be `T`.

* feat(google-maps): add constant for map type

* fix(file): platform Browser will raise a an DOMException (#1082)

fix(File): Platform Browser will raise a an DOMException on resoleLocalFilesystemUrl and tries to write on readonly property DOMException err.message in fillErrorMessage

* feat(local-notifications): support for icon background color (#1079)

The Cordova plugin Ionic Natives uses allows specifying the background color of the smallIcon.  By not including it in your interface you force users to use the default color for their version of Android.  While the LocalNotification plugin is not well documented, it does include this feature, see Options.java line 253:

```
/**
     * @return
     *      The notification background color for the small icon
     *      Returns null, if no color is given.
     */
    public int getColor() {
        String hex = options.optString("color", null);

        if (hex == null) {
            return NotificationCompat.COLOR_DEFAULT;
        }

        int aRGB = Integer.parseInt(hex, 16);

        return aRGB + 0xFF000000;
    }
```

I've simply added the option to the interface as well as a short description.

This lets you go from the default color (varies by Android version): https://goo.gl/photos/nERcj4GZgapy8aee9
To any color you'd like: https://goo.gl/photos/t8V9WVba8jDU49aHA
And also works if you also specify a large icon: https://goo.gl/photos/gWQYwa12djmdXfYcA

* feat(unique-device-add): add UniqueDeviceId plugin (#1064)

* fix plugin

* feat(text-to-speech): Add stop method (#1063)

https://github.com/vilic/cordova-plugin-tts/pull/32

* feat(appodeal): adds Appodeal SDK wrappers for iOS and Android (#1031)

* feat(Appodeal) bootrapping

* starting docs

* more docs

* feat(appodeal): add event Observables

* feat(appodeal): replace Cordova Observable events with #.fromEvent()

* feat(appodeal): update decorator metadata

* feat(couchbase-lite): add CouchbaseLite cordova plugin (#1025)

* feat(CouchbaseLite): add CouchbaseLite cordova plugin

* add plugin url

* feat(background-fetch): Adding Background Fetch requested in #990 (#1013)

* Adding Background Fetch (https://github.com/transistorsoft/cordova-plugin-background-fetch) requested in #990

* Adding BackgroundFetch to index

* feat(gyroscope): add Gyroscope plugin (#1004)

* add gyroscope.ts to plugins

* add gyroscope to index

* Update gyroscope.ts

* Update gyroscope.ts

* Revert "fix(File): typing where `FileError` can be thrown" (#1130)

* tslint and fix build issues

* 2.6.0

* chore(): update changelog

* fix(core): dont check if method exists when overriding

fixes #1043

* fix(file): fix writeExistingFile

closes #1044

* feat(diagnostic): add new methods

closes #1045

* feat(background-mode): replace event listeners with on method

The methods onactivate, ondeactive and onfailure no longer exist. You must now use `on` method.

* feat(background-mode): add missing functions

 closes #1078

* tslint

* set GoogleMapsMapTypeId to private

* remove beta from stripe

* 2.7.0

* chore(): update changelog

* feat(app-preferences): added cordova-plugin-app-preferences support (#1084)

* (feat) added cordova-plugin-app-preferences support

* replaced callback functions with promises

* updated example

* (feat) added cordova-plugin-browsertab support

* Revert "(feat) added cordova-plugin-browsertab support"

This reverts commit 00eb5cf5d8.

* (update) synchronize fetch

* feat(photo-library): added cordova-plugin-photo-library (#1102)

* feat(photo-library): added cordova-plugin-photo-library

* CordovaFiniteObservable moved to photo-library.
Overloads are marked as private.

* refactor(photo-library): fixed circleci failing in 2.7.0 (#1132)

* feat(photo-library): added cordova-plugin-photo-library

* CordovaFiniteObservable moved to photo-library.
Overloads are marked as private.

* fixed typescript error in 2.7.0

* feat(health): add wrapper for cordova-plugin-health (#1039)

* feat(health): add wrapper for cordova-plugin-health

* fix(Health): add optional params to QueryOptions for .query()

* docs(health): fix javadoc of interfaces

* fix(health): remove unused Plugin option

* docs(health): add missing documentation

* doc(health): add promise to return

* doc(health): remove empty lines

* doc(health): Add description & reference to repo

* doc(health: add "return {Promise<any>}"

* refactor(safari-view-controller): hide returns promise

* fix typo in ibeacon plugin (#1138)

* fix(file): fix return types

fixes #1139

* docs(background-geolocation): fix param docs

* refactor(health): fix return types and prefix interfaces

* 2.8.0

* chore(): update changelog

* docs(sqlite): syntax error resolved (#1142)

* Syntax error resolved

The `{}` should be `[]`, but since there is no binding we do not get error. In case we add one, then the syntax will be incorrect.

* Fixed a syntax error

* fix(background-geolocation): configure returns an observable

* docs(): update docs

* 3.1.0-rc.1

* refactor(background-geolocation): update imports

* docs(background-fetch): fix return type

* docs(health): fix return type

* chore(CI): fixing npm install instructions in generated readmes

* set concurrency to number of cores

* chore(): update deps

* 3.1.0-rc.2

* chore(): update angular to 2.4.8

* 3.1.0-rc.3

* chore(): update angular to 2.4.8

* chore(): update rxjs to 5.0.1

* chore(): organize and enhance decorators (#1171)

* fix/add decorators

* fix google maps design

* chore(): add root tsconfig to resolve imports in IDE

* updates

* more fixes

* chore(): add options to InstanceCheck

* chore(decorators): promise is default for Cordova/Instance check

* chore(): add check decroators

* docs(): update plugin docs

* chore(decorators): fix cordovaCheck and instanceCheck

* 3.1.0-rc.4

* chore(docs): remove gitPackage from doc generator

* chore(docs): update to latest dgeni version

* fix diagnostic

* feat(media): create method now returns a promise

Breaking change: create no longer returns a MediaObject instance. Make changes to your app accordingly.

* docs update + remove any static methods/properties

* remove duplicate method

* remove extra docs

* remove extra docs

* docs(): rename plugins

* chore(decorators): do not check method name on instancecheck

* chore(decorators): do not check method name on cordovacheck

* chore(plugin): fix pluginWarn

* chore(plugin): fix pluginWarn

* fix(decorators): fix InstanceCheck decorator

* 3.1.0-rc.5

* chore(docs): fix readme generation

* fix(transfer): fix v3 implementation

* refactor(paypal): PayPal is brand name

* chore(docs): replace all spaces with dashes

* chore(): add dashify filter

* chore(build): add aot path to core tsconfig

* feat(action-sheet): add ANDROID_THEMES constant

* refactor(): general cleanup (#1193)

* feat(screen-orientation): update wrapper to match v2 of the plugin

The whole implementation has changed now. You must update your code.

* feat(stripe): add new methods

* feat(linkedin): add LinkedIn plugin

* 3.1.0-rc.6

* style(screen-orientation): double quote to single

* tslint

* refactor(pedometer): rename file to index
This commit is contained in:
Ibby Hadeed
2017-03-20 16:38:14 -04:00
committed by GitHub
parent 8cd648db5c
commit 2f2d55f1d5
222 changed files with 6101 additions and 7958 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/@ionic-native/plugins/action-sheet/index.ts
+116
View File
@@ -0,0 +1,116 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin, CordovaProperty } from '@ionic-native/core';
export interface ActionSheetOptions {
/**
* The labels for the buttons. Uses the index x
*/
buttonLabels: string[];
/**
* The title for the actionsheet
*/
title?: string;
/**
* Theme to be used on Android
*/
androidTheme?: number;
/**
* Enable a cancel on Android
*/
androidEnableCancelButton?: boolean;
/**
* Enable a cancel on Windows Phone
*/
winphoneEnableCancelButton?: boolean;
/**
* Add a cancel button with text
*/
addCancelButtonWithLabel?: string;
/**
* Add a destructive button with text
*/
addDestructiveButtonWithLabel?: string;
/**
* On an iPad, set the X,Y position
*/
position?: number[];
}
/**
* @name Action Sheet
* @description
* The ActionSheet plugin shows a native list of options the user can choose from.
*
* Requires Cordova plugin: `cordova-plugin-actionsheet`. For more info, please see the [ActionSheet plugin docs](https://github.com/EddyVerbruggen/cordova-plugin-actionsheet).
*
* @usage
* ```typescript
* import { ActionSheet, ActionSheetOptions } from '@ionic-native/action-sheet';
*
* constructor(private actionSheet: ActionSheet) { }
*
* ...
*
*
* let buttonLabels = ['Share via Facebook', 'Share via Twitter'];
*
* const options: ActionSheetOptions = {
* title: 'What do you want with this image?',
* buttonLabels: buttonLabels,
* addCancelButtonWithLabel: 'Cancel',
* addDestructiveButtonWithLabel: 'Delete',
* androidTheme: this.actionSheet.ANDROID_THEMES.THEME_HOLO_DARK
* };
*
* this.actionSheet.show(options).then((buttonIndex: number) => {
* console.log('Button pressed: ' + buttonIndex);
* });
* ```
* @interfaces
* ActionSheetOptions
*/
@Plugin({
pluginName: 'ActionSheet',
plugin: 'cordova-plugin-actionsheet',
pluginRef: 'plugins.actionsheet',
repo: 'https://github.com/EddyVerbruggen/cordova-plugin-actionsheet',
platforms: ['Android', 'iOS', 'Windows Phone 8']
})
@Injectable()
export class ActionSheet {
@CordovaProperty
ANDROID_THEMES: {
THEME_TRADITIONAL: number;
THEME_HOLO_DARK: number;
THEME_HOLO_LIGHT: number;
THEME_DEVICE_DEFAULT_DARK: number;
THEME_DEVICE_DEFAULT_LIGHT: number;
};
/**
* Show a native ActionSheet component. See below for options.
* @param options {ActionSheetOptions} Options See table below
* @returns {Promise<any>} Returns a Promise that resolves with the index of the
* button pressed (1 based, so 1, 2, 3, etc.)
*/
@Cordova()
show(options?: ActionSheetOptions): Promise<any> { return; }
/**
* Progamtically hide the native ActionSheet
* @returns {Promise<any>} Returns a Promise that resolves when the actionsheet is closed
*/
@Cordova()
hide(options?: any): Promise<any> { return; }
}
src/@ionic-native/plugins/ad-mob/index.ts
+289
View File
@@ -0,0 +1,289 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export type AdSize = 'SMART_BANNER' | 'BANNER' | 'MEDIUM_RECTANGLE' | 'FULL_BANNER' | 'LEADERBOARD' | 'SKYSCRAPER' | 'CUSTOM';
export interface AdMobOptions {
/**
* Banner ad ID
*/
adId?: string;
/**
* Banner Ad Size, defaults to `SMART_BANNER`. IT can be: `SMART_BANNER`, `BANNER`, `MEDIUM_RECTANGLE`, `FULL_BANNER`, `LEADERBOARD`, `SKYSCRAPER`, or `CUSTOM`
*/
adSize?: AdSize;
/**
* Banner width, valid when `adSize` is set to `CUSTOM`
*/
width?: number;
/**
* Banner height, valid when `adSize` is set to `CUSTOM`
*/
height?: number;
/**
* Allow banner to overlap webview, or else it will push webview up or down to avoid overlap. Defaults to false.
*/
overlap?: boolean;
/**
* Position of banner ad. Defaults to `TOP_CENTER`. You can use the `AdMob.AD_POSITION` property to select other values.
*/
position?: number;
/**
* X in pixels. Valid when `position` is set to `POS_XY`
*/
x?: number;
/**
* Y in pixels. Valid when `position` is set to `POS_XY`
*/
y?: number;
/**
* Set to true to receive test ad for testing purposes
*/
isTesting?: boolean;
/**
* Auto show interstitial ad when loaded. Set to false if hope to control the show timing with prepareInterstitial/showInterstitial
*/
autoShow?: boolean;
/**
* Re-create the banner on web view orientation change (not screen orientation), or else just move the banner. Default:true.
*/
orientationRenew?: boolean;
/**
* Set extra color style for Ad
*/
adExtras?: AdExtras;
}
export interface AdExtras {
color_bg: string;
color_bg_top: string;
color_border: string;
color_link: string;
color_text: string;
color_url: string;
}
/**
* @name AdMob
* @description
* Plugin for Google Ads, including AdMob / DFP (doubleclick for publisher) and mediations to other Ad networks.
* @usage
* ```typescript
* import { AdMob, AdMobOptions, AdSize, AdExtras } from '@ionic-native/ad-mob';
*
* constructor(private admob: AdMob){}
*
* ionViewDidLoad() {
* this.admob.onAdDismiss()
* .subscribe(() => { console.log('User dismissed ad'); });
* }
*
* onClick() {
* this.admob.prepareInterstitial('YOUR_ADID')
* .then(() => { this.admob.showInterstitial(); });
* }
*
* ```
*
* @interfaces
* AdMobOptions
* AdExtras
*/
@Plugin({
pluginName: 'AdMob',
plugin: 'cordova-plugin-admobpro',
pluginRef: 'AdMob',
repo: 'https://github.com/floatinghotpot/cordova-admob-pro',
platforms: ['Android', 'iOS', 'Windows Phone 8']
})
@Injectable()
export class AdMob {
AD_POSITION: {
NO_CHANGE: number;
TOP_LEFT: number;
TOP_CENTER: number;
TOP_RIGHT: number;
LEFT: number;
CENTER: number;
RIGHT: number;
BOTTOM_LEFT: number;
BOTTOM_CENTER: number;
BOTTOM_RIGHT: number;
POS_XY: number;
} = {
NO_CHANGE: 0,
TOP_LEFT: 1,
TOP_CENTER: 2,
TOP_RIGHT: 3,
LEFT: 4,
CENTER: 5,
RIGHT: 6,
BOTTOM_LEFT: 7,
BOTTOM_CENTER: 8,
BOTTOM_RIGHT: 9,
POS_XY: 10
};
/**
* Create a banner
* @param adIdOrOptions {string | AdMobOptions} Ad ID or Options
* @returns {Promise<any>} Returns a Promise that resolves when the banner is created
*/
@Cordova()
createBanner(adIdOrOptions: string | AdMobOptions): Promise<any> { return; }
/**
* Destroy the banner, remove it from screen.
*/
@Cordova({
sync: true
})
removeBanner(): void { }
/**
* Show banner at position
* @param position {number} Position. Use `AdMob.AD_POSITION` to set values.
*/
@Cordova({
sync: true
})
showBanner(position: number): void { }
/**
* Show banner at custom position
* @param x {number} Offset from screen left.
* @param y {number} Offset from screen top.
*/
@Cordova({
sync: true
})
showBannerAtXY(x: number, y: number): void { }
/**
* Hide the banner, remove it from screen, but can show it later
*/
@Cordova({
sync: true
})
hideBanner(): void { }
/**
* Prepare interstitial banner
* @param adIdOrOptions {string | AdMobOptions} Ad ID or Options
* @returns {Promise<any>} Returns a Promise that resolves when interstitial is prepared
*/
@Cordova()
prepareInterstitial(adIdOrOptions: string | AdMobOptions): Promise<any> { return; }
/**
* Show interstitial ad when it's ready
*/
@Cordova({
sync: true
})
showInterstitial(): void { }
/**
* Prepare a reward video ad
* @param adIdOrOptions {string | AdMobOptions} Ad ID or Options
* @returns {Promise<any>} Returns a Promise that resolves when the ad is prepared
*/
@Cordova()
prepareRewardVideoAd(adIdOrOptions: string | AdMobOptions): Promise<any> { return; }
/**
* Show a reward video ad
*/
@Cordova({
sync: true
})
showRewardVideoAd(): void { }
/**
* Sets the values for configuration and targeting
* @param options {AdMobOptions} Options
* @returns {Promise<any>} Returns a Promise that resolves when the options have been set
*/
@Cordova()
setOptions(options: AdMobOptions): Promise<any> { return; }
/**
* Get user ad settings
* @returns {Promise<any>} Returns a promise that resolves with the ad settings
*/
@Cordova()
getAdSettings(): Promise<any> { return; }
/**
* Triggered when failed to receive Ad
* @returns {Observable<any>}
*/
@Cordova({
eventObservable: true,
event: 'onAdFailLoad'
})
onAdFailLoad(): Observable<any> { return; }
/**
* Triggered when Ad received
* @returns {Observable<any>}
*/
@Cordova({
eventObservable: true,
event: 'onAdLoaded'
})
onAdLoaded(): Observable<any> { return; }
/**
* Triggered when Ad will be showed on screen
* @returns {Observable<any>}
*/
@Cordova({
eventObservable: true,
event: 'onAdPresent'
})
onAdPresent(): Observable<any> { return; }
/**
* Triggered when user click the Ad, and will jump out of your App
* @returns {Observable<any>}
*/
@Cordova({
eventObservable: true,
event: 'onAdLeaveApp'
})
onAdLeaveApp(): Observable<any> { return; }
/**
* Triggered when dismiss the Ad and back to your App
* @returns {Observable<any>}
*/
@Cordova({
eventObservable: true,
event: 'onAdDismiss'
})
onAdDismiss(): Observable<any> { return; }
}
src/@ionic-native/plugins/alipay/index.ts
+115
View File
@@ -0,0 +1,115 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Injectable } from '@angular/core';
export interface AlipayOrder {
/**
* appId assigned by Alipay
*/
app_id: string;
/**
* Api name.
* Should be: alipay.trade.app.pay
*/
method: string;
/**
* Data format
* Default: "JSON"
*/
format?: string;
/**
* Charset
* Possible values: "UTF-8", "GBK"
* Default: "UTF-8"
*/
charset: string;
/**
* Sign method
* Default: 'RSA'
*/
sign_type: string;
/**
* Sign value. Should be got from server side.
* Default: 'RSA'
*/
sign: string;
/**
* Timestamp, formated like "yyyy-MM-dd HH:mm:ss", e.g. 2014-07-24 03:07:50
*/
timestamp: string;
/**
* Api version. Fixed value '1.0'
*/
version: string;
/**
* Notify url.
*/
notify_url: string;
/**
* biz content. formated in json. see alipay doc for detail.
*/
biz_content: string;
}
/**
* @name Alipay
* @description
* This plugin is used for Alipay APP support. Integrated with the latest SDK.
*
* Requires Cordova plugin: `cordova-alipay-base`. For more info, please see the [Alipay plugin docs](https://github.com/xueron/cordova-alipay-base).
*
* @usage
* ```
* import { Alipay, AlipayOrder } from '@ionic-native/alipay';
*
* constructor(private alipay: Alipay) {
*
* // Should get from server side with sign.
* const alipayOrder: AlipayOrder = {
* ...
* };
*
*
* this.alipay.pay(alipayOrder)
* .then(result => {
* console.log(result); // Success
* })
* .catch(error => {
* console.log(error); // Failed
* });
*
* }
*
*
* ```
*
* @interfaces
* AlipayOrder
*/
@Plugin({
pluginName: 'Alipay',
plugin: 'cordova-alipay-base',
pluginRef: 'Alipay.Base',
repo: 'https://github.com/xueron/cordova-alipay-base',
platforms: ['Android', 'iOS'],
install: 'ionic plugin add https://github.com/xueron/cordova-alipay-base --variable APP_ID=your_app_id'
})
@Injectable()
export class Alipay {
/**
* Open Alipay to perform App pay
* @param order { AlipayOrder } alipay options
* @returns {Promise<any>} Returns a Promise that resolves with the success return, or rejects with an error.
*/
@Cordova()
pay(order: AlipayOrder): Promise<any> { return; }
}
src/@ionic-native/plugins/android-fingerprint-auth/index.ts
+181
View File
@@ -0,0 +1,181 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface AFAAuthOptions {
/**
* Required
* Used as the alias for your key in the Android Key Store.
*/
clientId: string;
/**
* Used to create credential string for encrypted token and as alias to retrieve the cipher.
*/
username?: string;
/**
* Used to create credential string for encrypted token
*/
password?: string;
/**
* Required for decrypt()
* Encrypted user credentials to decrypt upon successful authentication.
*/
token?: string;
/**
* Set to true to remove the "USE BACKUP" button
*/
disableBackup?: boolean;
/**
* Change the language. (en_US or es)
*/
locale?: string;
/**
* The device max is 5 attempts. Set this parameter if you want to allow fewer than 5 attempts.
*/
maxAttempts?: number;
/**
* Require the user to authenticate with a fingerprint to authorize every use of the key.
* New fingerprint enrollment will invalidate key and require backup authenticate to
* re-enable the fingerprint authentication dialog.
*/
userAuthRequired?: boolean;
/**
* Set the title of the fingerprint authentication dialog.
*/
dialogTitle?: string;
/**
* Set the message of the fingerprint authentication dialog.
*/
dialogMessage?: string;
/**
* Set the hint displayed by the fingerprint icon on the fingerprint authentication dialog.
*/
dialogHint?: string;
}
export interface AFADecryptOptions {
/**
* Biometric authentication
*/
withFingerprint: boolean;
/**
* Authentication using backup credential activity
*/
withBackup: boolean;
/**
* FingerprintAuth.CipherMode.DECRYPT
* Decrypted password
*/
password: string;
}
export interface AFAEncryptResponse {
/**
* Biometric authentication
*/
withFingerprint: boolean;
/**
* Authentication using backup credential activity
*/
withBackup: boolean;
/**
* base64encoded string representation of user credentials
*/
token: string;
}
/**
* @name Android Fingerprint Auth
* @description
* This plugin will open a native dialog fragment prompting the user to authenticate using their fingerprint. If the device has a secure lockscreen (pattern, PIN, or password), the user may opt to authenticate using that method as a backup.
* @usage
* ```typescript
* import { AndroidFingerprintAuth, AFAAuthOptions } from '@ionic-native/android-fingerprint-auth';
*
* constructor(private androidFingerprintAuth: AndroidFingerprintAuth) { }
*
* ...
*
*
* this.androidFingerprintAuth.isAvailable()
* .then((result)=> {
* if(result.isAvailable){
* // it is available
*
* this.androidFingerprintAuth.encrypt({ clientId: "myAppName", username: "myUsername", password: "myPassword" })
* .then(result => {
* if (result.withFingerprint) {
* console.log("Successfully encrypted credentials.");
* console.log("Encrypted credentials: " + result.token);
* } else if (result.withBackup) {
* console.log('Successfully authenticated with backup password!');
* } else console.log('Didn\'t authenticate!');
* })
* .catch(error => {
* if (error === "Cancelled") {
* console.log("Fingerprint authentication cancelled");
* } else console.error(error)
* });
*
* } else {
* // fingerprint auth isn't available
* }
* })
* .catch(error => console.error(error));
* ```
* @interfaces
* AFAAuthOptions
* AFAEncryptResponse
* AFADecryptOptions
*/
@Plugin({
pluginName: 'AndroidFingerprintAuth',
plugin: 'cordova-plugin-android-fingerprint-auth',
pluginRef: 'FingerprintAuth',
repo: 'https://github.com/mjwheatley/cordova-plugin-android-fingerprint-auth'
})
@Injectable()
export class AndroidFingerprintAuth {
/**
* Opens a native dialog fragment to use the device hardware fingerprint scanner to authenticate against fingerprints registered for the device.
* @param options {AFAAuthOptions} Options
* @returns {Promise<any>}
*/
@Cordova()
encrypt(options: AFAAuthOptions): Promise<AFAEncryptResponse> {return; }
/**
* Opens a native dialog fragment to use the device hardware fingerprint scanner to authenticate against fingerprints registered for the device.
* @param options {AFAAuthOptions} Options
* @returns {Promise<any>}
*/
@Cordova()
decrypt(options: AFAAuthOptions): Promise<AFADecryptOptions> {return; }
/**
* Check if service is available
* @returns {Promise<any>} Returns a Promise that resolves if fingerprint auth is available on the device
*/
@Cordova()
isAvailable(): Promise<{isAvailable: boolean}> { return; }
/**
* Delete the cipher used for encryption and decryption by username
* @returns {Promise<any>} Returns a Promise that resolves if the cipher was successfully deleted
*/
@Cordova()
delete(options: {clientId: string; username: string; }): Promise<{deleted: boolean}> { return; }
}
src/@ionic-native/plugins/app-availability/index.ts
+53
View File
@@ -0,0 +1,53 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name App Availability
* @description
* This plugin allows you to check if an app is installed on the user's device. It requires an URI Scheme (e.g. twitter://) on iOS or a Package Name (e.g com.twitter.android) on Android.
*
* Requires Cordova plugin: cordova-plugin-appavailability. For more info, please see the [AppAvailability plugin docs](https://github.com/ohh2ahh/AppAvailability).
*
* @usage
* ```typescript
* import { AppAvailability } from '@ionic-native/app-availability';
* import { Platform } from 'ionic-angular';
*
* constructor(private appAvailability: AppAvailability, private platform: Platform) { }
*
* ...
*
* let app;
*
* if (this.platform.is('ios')) {
* app = 'twitter://';
* } else if (this.platform.is('android')) {
* app = 'com.twitter.android';
* }
*
* this.appAvailability.check(app)
* .then(
* (yes: string) => console.log(app + ' is available'),
* (no: string) => console.log(app + ' is NOT available')
* );
* ```
*/
@Plugin({
pluginName: 'AppAvailability',
plugin: 'cordova-plugin-appavailability',
pluginRef: 'appAvailability',
repo: 'https://github.com/ohh2ahh/AppAvailability',
platforms: ['Android', 'iOS']
})
@Injectable()
export class AppAvailability {
/**
* Checks if an app is available on device
* @param {string} app Package name on android, or URI scheme on iOS
* @returns {Promise<boolean>}
*/
@Cordova()
check(app: string): Promise<boolean> { return; }
}
src/@ionic-native/plugins/app-preferences/index.ts
+139
View File
@@ -0,0 +1,139 @@
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
import { Injectable } from '@angular/core';
/**
* @name App Preferences
* @description
* This plugin allows you to read and write app preferences
*
* @usage
* ```typescript
* import { AppPreferences } from '@ionic-native/app-preferences';
*
* constructor(private appPreferences: AppPreferences) {
*
* this.appPreferences.fetch('key').then((res) => { console.log(res); });
*
* }
* ```
*
*/
@Plugin({
pluginName: 'AppPreferences',
plugin: 'cordova-plugin-app-preferences', // npm package name, example: cordova-plugin-camera
pluginRef: 'plugins.appPreferences', // the variable reference to call the plugin, example: navigator.geolocation
repo: 'https://github.com/apla/me.apla.cordova.app-preferences', // the github repository URL for the plugin
})
@Injectable()
export class AppPreferences {
/**
* Get a preference value
*
* @param {string} dict Dictionary for key (OPTIONAL)
* @param {string} key Key
* @return {Promise<any>} Returns a promise
*/
@Cordova({
sync: true,
callbackOrder: 'reverse'
})
fetch(dict: string, key?: string): Promise<any> { return; }
/**
* Set a preference value
*
* @param {string} dict Dictionary for key (OPTIONAL)
* @param {string} key Key
* @param {string} value Value
* @return {Promise<any>} Returns a promise
*/
@Cordova({
callbackOrder: 'reverse'
})
store(dict: string, key: string, value?: string): Promise<any> {
return;
}
/**
* Remove value from preferences
*
* @param {string} dict Dictionary for key (OPTIONAL)
* @param {string} key Key
* @return {Promise<any>} Returns a promise
*/
@Cordova({
callbackOrder: 'reverse'
})
remove(dict: string, key?: string): Promise<any> { return; }
/**
* Clear preferences
*
* @return {Promise<any>} Returns a promise
*/
@Cordova({
callbackOrder: 'reverse'
})
clearAll(): Promise<any> { return; }
/**
* Show native preferences interface
*
* @return {Promise<any>} Returns a promise
*/
@Cordova({
callbackOrder: 'reverse'
})
show(): Promise<any> { return; }
/**
* Show native preferences interface
*
* @param {boolean} subscribe true value to subscribe, false - unsubscribe
* @return {Observable<any>} Returns an observable
*/
@Cordova({
observable: true
})
watch(subscribe: boolean): Observable<any> { return; }
/**
* Return named configuration context
* In iOS you'll get a suite configuration, on Android — named file
* Supports: Android, iOS
* @param {string} suiteName suite name
* @returns {Object} Custom object, bound to that suite
*/
@Cordova({
platforms: ['Android']
})
suite(suiteName: string): Object { return; }
@Cordova({
platforms: ['iOS']
})
iosSuite(suiteName: string): Object { return; }
/**
* Return cloud synchronized configuration context
* Currently supports Windows and iOS/macOS
* @returns {Object} Custom object, bound to that suite
*/
@Cordova({
platforms: ['iOS', 'Windows', 'Windows Phone 8']
})
cloudSync(): Object { return; }
/**
* Return default configuration context
* Currently supports Windows and iOS/macOS
* @returns {Object} Custom Object, bound to that suite
*/
@Cordova({
platforms: ['iOS', 'Windows', 'Windows Phone 8']
})
defaults(): Object { return; }
}
src/@ionic-native/plugins/app-rate/index.ts
+153
View File
@@ -0,0 +1,153 @@
import { Injectable } from '@angular/core';
import { Cordova, CordovaProperty, Plugin } from '@ionic-native/core';
declare var window;
export interface AppRatePreferences {
/**
* Custom BCP 47 language tag
*/
useLanguage?: string;
/**
* Custom application title
*/
displayAppName?: string;
/**
* Show dialog again when application version will be updated. Defaults to `true`
*/
promptAgainForEachNewVersion?: boolean;
/**
* count of runs of application before dialog will be displayed. Defaults to `3`
*/
usesUntilPrompt?: number;
/**
* leave app or no when application page opened in app store (now supported only for iOS). Defaults to `false`
*/
openStoreInApp?: boolean;
/**
* use custom view for rate dialog. Defaults to `false`
*/
useCustomRateDialog?: boolean;
/**
* Custom locale object
*/
customLocale?: any;
/**
* Callbacks for events
*/
callbacks?: AppRateCallbacks;
/**
* App Store URLS
*/
storeAppURL?: AppUrls;
}
export interface AppRateCallbacks {
/**
* call back function. called when user clicked on rate-dialog buttons
*/
onButtonClicked?: Function;
/**
* call back function. called when rate-dialog showing
*/
onRateDialogShow?: Function;
}
export interface AppUrls {
/**
* application id in AppStore
*/
ios?: string;
/**
* application URL in GooglePlay
*/
android?: string;
/**
* application URL in Windows Store
*/
windows?: string;
/**
* application URL in AppWorld
*/
blackberry?: string;
/**
* application URL in WindowsStore
*/
windows8?: string;
}
/**
* @name App Rate
* @description
* The AppRate plugin makes it easy to prompt the user to rate your app, either now, later, or never.
*
* Requires Cordova plugin: cordova-plugin-apprate. For more info, please see the [AppRate plugin docs](https://github.com/pushandplay/cordova-plugin-apprate).
*
* @usage
* ```typescript
* import { AppRate } from '@ionic-native/app-rate';
*
* constructor(private appRate: AppRate) { }
*
* ...
*
* this.appRate.preferences.storeAppURL = {
* ios: '<my_app_id>',
* android: 'market://details?id=<package_name>',
* windows: 'ms-windows-store://review/?ProductId=<Store_ID>'
* };
*
* this.appRate.promptForRating(false);
* ```
*
* @interfaces
* AppRatePreferences
* AppUrls
* AppRateCallbacks
*
*/
@Plugin({
pluginName: 'AppRate',
plugin: 'cordova-plugin-apprate',
pluginRef: 'AppRate',
repo: 'https://github.com/pushandplay/cordova-plugin-apprate',
platforms: ['Android', 'iOS', 'Windows (experimental)']
})
@Injectable()
export class AppRate {
/**
* Configure various settings for the Rating View.
* See table below for options
*/
@CordovaProperty
preferences: AppRatePreferences;
/**
* Prompts the user for rating
* @param {boolean} immediately Show the rating prompt immediately.
*/
@Cordova()
promptForRating(immediately: boolean): void { };
}
src/@ionic-native/plugins/app-update/index.ts
+56
View File
@@ -0,0 +1,56 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Injectable } from '@angular/core';
/**
* @name App Update
* @description
* This plugin does self-update for android
*
* @usage
*
* You should first host an XML file on your server with the following data in it:
* ```xml
* <update>
* <version>302048</version>
* <name>APK Name</name>
* <url>https://your-remote-api.com/YourApp.apk</url>
* </update>
* ```
*
* Then use the following code:
*
* ```
* import { AppUpdate } from '@ionic-native/app-update';
*
* constructor(private appUpdate: AppUpdate) {
*
* const updateUrl = 'http://your-remote-api.com/update.xml';
* this.appUpdate.checkAppUpdate(updateUrl);
*
* }
*
*
* ```
*
* The plugin will compare the app version and update it automatically if the API has a newer version to install.
*/
@Plugin({
pluginName: 'AppUpdate',
plugin: 'cordova-plugin-app-update',
pluginRef: 'AppUpdate',
repo: 'https://github.com/vaenow/cordova-plugin-app-update',
platforms: ['Android']
})
@Injectable()
export class AppUpdate {
/**
* Check and update
* @param updateUrl {string} update api url
* @return {Promise<any>} Returns a promise that resolves when something happens
*/
@Cordova({
callbackOrder: 'reverse'
})
checkAppUpdate(updateUrl: string): Promise<any> { return; }
}
src/@ionic-native/plugins/app-version/index.ts
+67
View File
@@ -0,0 +1,67 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name App Version
* @description
* Reads the version of your app from the target build settings.
*
* Requires Cordova plugin: `cordova-plugin-app-version`. For more info, please see the [Cordova App Version docs](https://github.com/whiteoctober/cordova-plugin-app-version).
*
* @usage
* ```typescript
* import { AppVersion } from '@ionic-native/app-version';
*
* constructor(private appVersion: AppVersion) { }
*
* ...
*
*
* this.appVersion.getAppName();
* this.appVersion.getPackageName();
* this.appVersion.getVersionCode();
* this.appVersion.getVersionNumber();
*
* ```
*/
@Plugin({
pluginName: 'AppVersion',
plugin: 'cordova-plugin-app-version',
pluginRef: 'cordova.getAppVersion',
repo: 'https://github.com/whiteoctober/cordova-plugin-app-version',
platforms: ['Android', 'iOS']
})
@Injectable()
export class AppVersion {
/**
* Returns the name of the app
* @returns {Promise<any>}
*/
@Cordova()
getAppName(): Promise<any> { return; }
/**
* Returns the package name of the app
* @returns {Promise<any>}
*/
@Cordova()
getPackageName(): Promise<any> { return; }
/**
* Returns the build identifier of the app
* @returns {Promise<any>}
*/
@Cordova()
getVersionCode(): Promise<any> { return; }
/**
* Returns the version of the app
* @returns {Promise<any>}
*/
@Cordova()
getVersionNumber(): Promise<any> { return; }
}
src/@ionic-native/plugins/appodeal/index.ts
+519
View File
@@ -0,0 +1,519 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Observable } from 'rxjs';
import { Injectable } from '@angular/core';
/**
* @name Appodeal
* @description
* Plugin to serve ads through native Appodeal SDKs
*
* @usage
* ```
* import { Appodeal } from '@ionic-native/appodeal';
*
* constructor(private appodeal: Appodeal) {
*
* const appKey = '<your app key>';
* appodeal.initialize(appKey, appodeal.AD_TYPES.REWARDED_VIDEO);
* appodeal.show(appodeal.AD_TYPES.REWARDED_VIDEO);
*
* }
*
*
*
* ```
*/
@Plugin({
pluginName: 'Appodeal',
plugin: 'https://github.com/appodeal/appodeal-cordova-plugin',
pluginRef: 'Appodeal',
repo: 'https://github.com/appodeal/appodeal-cordova-plugin.git',
platforms: [ 'ios', 'android' ]
})
@Injectable()
export class Appodeal {
// available types of advertisements
readonly AD_TYPES = {
INTERSTITIAL: 1,
SKIPPABLE_VIDEO: 2,
BANNER: 4,
BANNER_BOTTOM: 8,
BANNER_TOP: 16,
REWARDED_VIDEO: 128,
NON_SKIPPABLE_VIDEO: 256
};
/**
* initialize Appodeal SDK
* @param {string} appKey
* @param {number} adType
*/
@Cordova()
initialize(appKey: string, adType: number): void {};
/**
* check if SDK has been initialized
* @returns {Promise<boolean>}
*/
@Cordova()
isInitialized(): Promise<any> { return; };
/**
* show ad of specified type
* @param {number} adType
* @returns {Promise<boolean>}
*/
@Cordova()
show(adType: number): Promise<any> { return; };
/**
* show ad of specified type with placement options
* @param {number} adType
* @param {any} placement
* @returns {Promise<boolean>}
*/
@Cordova()
showWithPlacement(
adType: number,
placement: any
): Promise<any> { return; };
/**
* hide ad of specified type
* @param {number} adType
*/
@Cordova()
hide(adType: number): void {};
/**
* confirm use of ads of specified type
* @param {number} adType
*/
@Cordova()
confirm(adType: number): void {};
/**
* check if ad of specified type has been loaded
* @param {number} adType
* @returns {Promise<boolean>}
*/
@Cordova()
isLoaded(adType: number): Promise<any> { return; };
/**
* check if ad of specified
* @param {number} adType
* @returns {Promise<boolean>}
*/
@Cordova()
isPrecache(adType: number): Promise<any> { return; };
/**
*
* @param {number} adType
* @param autoCache
*/
@Cordova()
setAutoCache(adType: number, autoCache: any): void {};
/**
* forcefully cache an ad by type
* @param {number} adType
*/
@Cordova()
cache(adType: number): void {};
/**
*
* @param {boolean} set
*/
@Cordova()
setOnLoadedTriggerBoth(set: boolean): void {};
/**
* enable or disable Smart Banners
* @param {boolean} enabled
*/
@Cordova()
setSmartBanners(enabled: boolean): void {};
/**
* enable or disable banner backgrounds
* @param {boolean} enabled
*/
@Cordova()
setBannerBackground(enabled: boolean): void {};
/**
* enable or disable banner animations
* @param {boolean} enabled
*/
@Cordova()
setBannerAnimation(enabled: boolean): void {};
/**
*
* @param value
*/
@Cordova()
set728x90Banners(value: any): void {};
/**
* enable or disable logging
* @param {boolean} logging
*/
@Cordova()
setLogging(logging: boolean): void {};
/**
* enable or disable testing mode
* @param {boolean} testing
*/
@Cordova()
setTesting(testing: boolean): void {};
/**
* reset device ID
*/
@Cordova()
resetUUID(): void {};
/**
* get version of Appdeal SDK
*/
@Cordova()
getVersion(): Promise<any> { return; };
/**
*
* @param {string} network
* @param {number} adType
*/
@Cordova()
disableNetwork(network?: string, adType?: number): void {};
/**
*
* @param {string} network
* @param {number} adType
*/
@Cordova()
disableNetworkType(network?: string, adType?: number): void {};
/**
* disable Location permissions for Appodeal SDK
*/
@Cordova()
disableLocationPermissionCheck(): void {};
/**
* disable Storage permissions for Appodeal SDK
*/
@Cordova()
disableWriteExternalStoragePermissionCheck(): void {};
/**
* enable event listeners
* @param {boolean} enabled
*/
@Cordova()
enableInterstitialCallbacks(enabled: boolean): void {};
/**
* enable event listeners
* @param {boolean} enabled
*/
@Cordova()
enableSkippableVideoCallbacks(enabled: boolean): void {};
/**
* enable event listeners
* @param {boolean} enabled
*/
@Cordova()
enableNonSkippableVideoCallbacks(enabled: boolean): void {};
/**
* enable event listeners
* @param {boolean} enabled
*/
@Cordova()
enableBannerCallbacks(enabled: boolean): void {};
/**
* enable event listeners
* @param {boolean} enabled
*/
@Cordova()
enableRewardedVideoCallbacks(enabled: boolean): void {};
/**
*
* @param {string} name - name of rule
* @param {boolean} value
*/
@Cordova()
setCustomBooleanRule(name: string, value: boolean): void {};
/**
*
* @param {string} name - name of rule
* @param {number} value
*/
@Cordova()
setCustomIntegerRule(name: string, value: number): void {};
/**
* set rule with float value
* @param {string} name
* @param {number} value
*/
@Cordova()
setCustomDoubleRule(name: string, value: number): void {};
/**
* set rule with string value
* @param {string} name - name of rule
* @param {string} value
*/
@Cordova()
setCustomStringRule(name: string, value: string): void {};
/**
* set ID preference in Appodeal for current user
* @param id
*/
@Cordova()
setUserId(id: any): void {};
/**
* set Email preference in Appodeal for current user
* @param email
*/
@Cordova()
setEmail(email: any): void {};
/**
* set Birthday preference in Appodeal for current user
* @param birthday
*/
@Cordova()
setBirthday(birthday: any): void {};
/**
* et Age preference in Appodeal for current user
* @param age
*/
@Cordova()
setAge(age: any): void {};
/**
* set Gender preference in Appodeal for current user
* @param gender
*/
@Cordova()
setGender(gender: any): void {};
/**
* set Occupation preference in Appodeal for current user
* @param occupation
*/
@Cordova()
setOccupation(occupation: any): void {};
/**
* set Relation preference in Appodeal for current user
* @param relation
*/
@Cordova()
setRelation(relation: any): void {};
/**
* set Smoking preference in Appodeal for current user
* @param smoking
*/
@Cordova()
setSmoking(smoking: any): void {};
/**
* set Alcohol preference in Appodeal for current user
* @param alcohol
*/
@Cordova()
setAlcohol(alcohol: any): void {};
/**
* set Interests preference in Appodeal for current user
* @param interests
*/
@Cordova()
setInterests(interests: any): void {};
@Cordova({
eventObservable: true,
event: 'onInterstitialLoaded',
element: document
})
onInterstitialLoaded(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onInterstitialFailedToLoad',
element: document
})
onInterstitialFailedToLoad(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onInterstitialShown',
element: document
})
onInterstitialShown(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onInterstitialClicked',
element: document
})
onInterstitialClicked(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onInterstitialClosed',
element: document
})
onInterstitialClosed(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onSkippableVideoLoaded',
element: document
})
onSkippableVideoLoaded(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onSkippableVideoFailedToLoad',
element: document
})
onSkippableVideoFailedToLoad(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onSkippableVideoShown',
element: document
})
onSkippableVideoShown(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onSkippableVideoFinished',
element: document
})
onSkippableVideoFinished(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onSkippableVideoClosed',
element: document
})
onSkippableVideoClosed(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onRewardedVideoLoaded',
element: document
})
onRewardedVideoLoaded(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onRewardedVideoFailedToLoad',
element: document
})
onRewardedVideoFailedToLoad(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onRewardedVideoShown',
element: document
})
onRewardedVideoShown(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onRewardedVideoFinished',
element: document
})
onRewardedVideoFinished(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onRewardedVideoClosed',
element: document
})
onRewardedVideoClosed(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onNonSkippableVideoLoaded',
element: document
})
onNonSkippableVideoLoaded(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onNonSkippableVideoFailedToLoad',
element: document
})
onNonSkippableVideoFailedToLoad(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onNonSkippableVideoShown',
element: document
})
onNonSkippableVideoShown(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onNonSkippableVideoFinished',
element: document
})
onNonSkippableVideoFinished(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onNonSkippableVideoClosed',
element: document
})
onNonSkippableVideoClosed(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onBannerClicked',
element: document
})
onBannerClicked(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onBannerFailedToLoad',
element: document
})
onBannerFailedToLoad(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onBannerLoaded',
element: document
})
onBannerLoaded(): Observable<any> { return; }
@Cordova({
eventObservable: true,
event: 'onBannerShown',
element: document
})
onBannerShown(): Observable<any> { return; }
}
src/@ionic-native/plugins/background-fetch/index.ts
+103
View File
@@ -0,0 +1,103 @@
import { Cordova, Plugin } from '@ionic-native/core';
import { Injectable } from '@angular/core';
declare var window;
export interface BackgroundFetchConfig {
/**
* Set true to cease background-fetch from operating after user "closes" the app. Defaults to true.
*/
stopOnTerminate?: boolean;
}
/**
* @name Background Fetch
* @description
* iOS Background Fetch Implementation. See: https://developer.apple.com/reference/uikit/uiapplication#1657399
* iOS Background Fetch is basically an API which wakes up your app about every 15 minutes (during the user's prime-time hours) and provides your app exactly 30s of background running-time. This plugin will execute your provided callbackFn whenever a background-fetch event occurs. There is no way to increase the rate which a fetch-event occurs and this plugin sets the rate to the most frequent possible value of UIApplicationBackgroundFetchIntervalMinimum -- iOS determines the rate automatically based upon device usage and time-of-day (ie: fetch-rate is about ~15min during prime-time hours; less frequently when the user is presumed to be sleeping, at 3am for example).
* For more detail, please see https://github.com/transistorsoft/cordova-plugin-background-fetch
*
* @usage
*
* ```typescript
* import { BackgroundFetch, BackgroundFetchConfig } from '@ionic-native/background-fetch';
*
*
* constructor(private backgroundFetch: BackgroundFetch) {
*
* const config: BackgroundFetchConfig = {
* stopOnTerminate: false, // Set true to cease background-fetch from operating after user "closes" the app. Defaults to true.
* };
*
* backgroundFetch.configure(config)
* .then(() => {
* console.log('Background Fetch initialized');
*
* this.backgroundFetch.finish();
*
* })
* .catch(e => console.log('Error initializing background fetch', e));
*
* // Start the background-fetch API. Your callbackFn provided to #configure will be executed each time a background-fetch event occurs. NOTE the #configure method automatically calls #start. You do not have to call this method after you #configure the plugin
* backgroundFetch.start();
*
* // Stop the background-fetch API from firing fetch events. Your callbackFn provided to #configure will no longer be executed.
* backgroundFetch.stop();
*
*
* }
*
* ```
* @interfaces
* BackgroundFetchConfig
*
*/
@Plugin({
pluginName: 'BackgroundFetch',
plugin: 'cordova-plugin-background-fetch',
pluginRef: 'BackgroundFetch',
repo: 'https://github.com/transistorsoft/cordova-plugin-background-fetch',
platforms: ['iOS']
})
@Injectable()
export class BackgroundFetch {
/**
* Configures the plugin's fetch callbackFn
*
* @param {BackgroundFetchConfig} config Configuration for plugin
* @return {Promise<any>}
*/
@Cordova({
callbackOrder: 'reverse'
})
configure(config: BackgroundFetchConfig): Promise<any> { return; }
/**
* Start the background-fetch API.
* Your callbackFn provided to #configure will be executed each time a background-fetch event occurs. NOTE the #configure method automatically calls #start. You do not have to call this method after you #configure the plugin
* @returns {Promise<any>}
*/
@Cordova()
start(): Promise<any> { return; }
/**
* Stop the background-fetch API from firing fetch events. Your callbackFn provided to #configure will no longer be executed.
* @returns {Promise<any>}
*/
@Cordova()
stop(): Promise<any> { return; }
/**
* You MUST call this method in your fetch callbackFn provided to #configure in order to signal to iOS that your fetch action is complete. iOS provides only 30s of background-time for a fetch-event -- if you exceed this 30s, iOS will kill your app.
*/
@Cordova({
sync: true
})
finish(): void { }
}
src/@ionic-native/plugins/background-geolocation/index.ts
+548
View File
@@ -0,0 +1,548 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
declare var window;
export interface BackgroundGeolocationResponse {
/**
* ID of location as stored in DB (or null)
*/
locationId: number;
/**
* Service provider
*/
serviceProvider: string;
/**
* true if location recorded as part of debug
*/
debug: boolean;
/**
* UTC time of this fix, in milliseconds since January 1, 1970.
*/
time: number;
/**
* latitude, in degrees.
*/
latitude: number;
/**
* longitude, in degrees.
*/
longitude: number;
/**
* estimated accuracy of this location, in meters.
*/
accuracy: number;
/**
* speed if it is available, in meters/second over ground.
*/
speed: number;
/**
* altitude if available, in meters above the WGS 84 reference ellipsoid.
*/
altitude: number;
/**
* accuracy of the altitude if available.
*/
altitudeAccuracy: number;
/**
* bearing, in degrees.
*/
bearing: number;
/**
* A Coordinates object defining the current location
*/
coords: Coordinates;
/**
* A timestamp representing the time at which the location was retrieved.
*/
timestamp: number;
}
export interface BackgroundGeolocationConfig {
/**
* Desired accuracy in meters. Possible values [0, 10, 100, 1000]. The lower
* the number, the more power devoted to GeoLocation resulting in higher
* accuracy readings. 1000 results in lowest power drain and least accurate
* readings. @see Apple docs (https://developer.apple.com/library/ios/documentation/CoreLocation/Reference/CLLocationManager_Class/index.html#//apple_ref/occ/instp/CLLocationManager/desiredAccuracy)
*/
desiredAccuracy: number;
/**
* Stationary radius in meters. When stopped, the minimum distance the device
* must move beyond the stationary location for aggressive background-tracking
* to engage.
*/
stationaryRadius: number;
/**
* When enabled, the plugin will emit sounds for life-cycle events of
* background-geolocation! See debugging sounds table.
*/
debug?: boolean;
/**
* The minimum distance (measured in meters) a device must move horizontally
* before an update event is generated. @see Apple docs. (https://developer.apple.com/library/ios/documentation/CoreLocation/Reference/CLLocationManager_Class/CLLocationManager/CLLocationManager.html#//apple_ref/occ/instp/CLLocationManager/distanceFilter)
*/
distanceFilter: number;
/**
* IOS, ANDROID ONLY
* Enable this in order to force a stop() when the application terminated
* (e.g. on iOS, double-tap home button, swipe away the app).o
*
* Defaults to true
*/
stopOnTerminate?: boolean;
/**

* ANDROID ONLY

* Start background service on device boot.

*
* Defaults to false

*/
startOnBoot?: boolean;
/**

* ANDROID ONLY

* If false location service will not be started in foreground and no notification will be shown.
*
* Defaults to true

*/
startForeground?: boolean;
/**
* ANDROID, WP8 ONLY
* When using BackgroundGeolocation.LocationProvider.ANDROID_DISTANCE_FILTER_PROVIDER:
* The minimum time interval between location updates in milliseconds.
* @see Android docs (http://developer.android.com/reference/android/location/LocationManager.html#requestLocationUpdates(long,%20float,%20android.location.Criteria,%20android.app.PendingIntent))
* and the MS doc (http://msdn.microsoft.com/en-us/library/windows/apps/windows.devices.geolocation.geolocator.reportinterval)
* for more information
* When using BackgroundGeolocation.LocationProvider.ANDROID_ACTIVITY_PROVIDER:
* Rate in milliseconds at which your app prefers to receive location updates.
* @see Android docs (https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest.html#getInterval())
*/
interval?: number;
/**
* ANDROID ONLY
* Custom notification title in the drawer.
*/
notificationTitle?: string;
/**
* ANDROID ONLY
* Custom notification text in the drawer.
*/
notificationText?: string;
/**
* ANDROID ONLY
* The accent color to use for notification. Eg. #4CAF50.
*/
notificationIconColor?: string;
/**

* ANDROID ONLY

* The filename of a custom notification icon. See android quirks.

* NOTE: Only available for API Level >=21.

*/
notificationIconLarge?: string;
/**

* ANDROID ONLY

* The filename of a custom notification icon. See android quirks.

* NOTE: Only available for API Level >=21.

*/
notificationIconSmall?: string;
/**
* ANDROID ONLY
* Set location service provider @see wiki (https://github.com/mauron85/cordova-plugin-background-geolocation/wiki/Android-providers)
*/
locationProvider?: number;
/**
* IOS ONLY
* [AutomotiveNavigation, OtherNavigation, Fitness, Other] Presumably,
* this affects iOS GPS algorithm. @see Apple docs for more information
* (https://developer.apple.com/library/ios/documentation/CoreLocation/Reference/CLLocationManager_Class/CLLocationManager/CLLocationManager.html#//apple_ref/occ/instp/CLLocationManager/activityType)
*/
activityType?: string;
/**

* IOS ONLY

* Pauses location updates when app is paused

*
* Defaults to true

*/
pauseLocationUpdates?: boolean;
/**

* Server url where to send HTTP POST with recorded locations

* @see https://github.com/mauron85/cordova-plugin-background-geolocation#http-locations-posting

*/
url?: string;
/**

* Server url where to send fail to post locations

* @see https://github.com/mauron85/cordova-plugin-background-geolocation#http-locations-posting

*/
syncUrl?: string;
/**
* Specifies how many previously failed locations will be sent to server at once

*
* Defaults to 100

*/
syncThreshold?: number;
/**

* Optional HTTP headers sent along in HTTP request

*/
httpHeaders?: any;
/**
* IOS ONLY

* Switch to less accurate significant changes and region monitory when in background (default)
*
* Defaults to 100

*/
saveBatteryOnBackground?: boolean;
/**

* Limit maximum number of locations stored into db

*
* Defaults to 10000

*/
maxLocations?: number;
/**
* ANDROID ONLY with BackgroundGeolocation.LocationProvider.ANDROID_ACTIVITY_PROVIDER
*
* Fastest rate in milliseconds at which your app can handle location updates.
* @see Android docs (https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest.html#getFastestInterval())
*/
fastestInterval?: number;
/**
* ANDROID ONLY with BackgroundGeolocation.LocationProvider.ANDROID_ACTIVITY_PROVIDER
*
* Rate in milliseconds at which activity recognition occurs. Larger values will result in fewer activity detections while improving battery life.
*/
activitiesInterval?: number;
/**
* ANDROID ONLY with BackgroundGeolocation.LocationProvider.ANDROID_ACTIVITY_PROVIDER
*
* stop() is forced, when the STILL activity is detected (default is true)
*/
stopOnStillActivity?: boolean;
}
/**
* @name Background Geolocation
* @description
* This plugin provides foreground and background geolocation with battery-saving "circular region monitoring" and "stop detection". For
* more detail, please see https://github.com/mauron85/cordova-plugin-background-geolocation
*
* @usage
*
* BackgroundGeolocation must be called within app.ts and or before Geolocation. Otherwise the platform will not ask you for background tracking permission.
*
* ```typescript
* import { BackgroundGeolocation, BackgroundGeolocationConfig } from '@ionic-native/background-geolocation';
*
* constructor(private backgroundGeolocation: BackgroundGeolocation) { }
*
* ...
*
* const config: BackgroundGeolocationConfig = {
* desiredAccuracy: 10,
* stationaryRadius: 20,
* distanceFilter: 30,
* debug: true, // enable this hear sounds for background-geolocation life-cycle.
* stopOnTerminate: false, // enable this to clear background location settings when the app terminates
* };
*
* this.backgroundGeolocation.configure(config)
* .subscribe((location: BackgroundGeolocationResponse) => {
*
* console.log(location);
*
* // IMPORTANT: You must execute the finish method here to inform the native plugin that you're finished,
* // and the background-task may be completed. You must do this regardless if your HTTP request is successful or not.
* // IF YOU DON'T, ios will CRASH YOUR APP for spending too much time in the background.
* BackgroundGeolocation.finish(); // FOR IOS ONLY
*
* });
*
* // start recording location
* this.backgroundGeolocation.start();
*
* // If you wish to turn OFF background-tracking, call the #stop method.
* this.backgroundGeolocation.stop();
*
* ```
* @interfaces
* BackgroundGeolocationResponse
* BackgroundGeolocationConfig
*/
@Plugin({
pluginName: 'BackgroundGeolocation',
plugin: 'cordova-plugin-mauron85-background-geolocation',
pluginRef: 'backgroundGeolocation',
repo: 'https://github.com/mauron85/cordova-plugin-background-geolocation',
platforms: ['iOS', 'Android', 'Windows Phone 8']
})
@Injectable()
export class BackgroundGeolocation {
/**

* Set location service provider @see https://github.com/mauron85/cordova-plugin-background-geolocation/wiki/Android-providers

*
* Possible values:
* ANDROID_DISTANCE_FILTER_PROVIDER: 0,

* ANDROID_ACTIVITY_PROVIDER: 1

*
* @enum {number}

*/
LocationProvider: any = {
ANDROID_DISTANCE_FILTER_PROVIDER: 0,
ANDROID_ACTIVITY_PROVIDER: 1
};
/**
* Desired accuracy in meters. Possible values [0, 10, 100, 1000].

* The lower the number, the more power devoted to GeoLocation resulting in higher accuracy readings.

* 1000 results in lowest power drain and least accurate readings.

*
* Possible values:
* HIGH: 0

* MEDIUM: 10

* LOW: 100

* PASSIVE: 1000
*
* enum {number}

*/
Accuracy: any = {
HIGH: 0,
MEDIUM: 10,
LOW: 100,
PASSIVE: 1000
};
/**

* Used in the switchMode function

*
* Possible values:
* BACKGROUND: 0
* FOREGROUND: 1

*
* @enum {number}

*/
Mode: any = {
BACKGROUND: 0,
FOREGROUND: 1
};
/**
* Configure the plugin.
*
* @param options {BackgroundGeolocationConfig} options An object of type Config
* @return {Observable<BackgroundGeolocationResponse>}
*/
@Cordova({
callbackOrder: 'reverse',
observable: true
})
configure(options: BackgroundGeolocationConfig): Observable<BackgroundGeolocationResponse> { return; }
/**
* Turn ON the background-geolocation system.
* The user will be tracked whenever they suspend the app.
* @returns {Promise<any>}
*/
@Cordova()
start(): Promise<any> { return; }
/**
* Turn OFF background-tracking
* @returns {Promise<any>}
*/
@Cordova()
stop(): Promise<any> { return; }
/**
* Inform the native plugin that you're finished, the background-task may be completed
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['iOS', 'Windows Phone']
})
finish(): Promise<any> { return; }
/**
* Force the plugin to enter "moving" or "stationary" state
* @param isMoving {boolean}
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['iOS', 'Windows Phone']
})
changePace(isMoving: boolean): Promise<any> { return; }
/**
* Setup configuration
* @param options {BackgroundGeolocationConfig}
* @returns {Promise<any>}
*/
@Cordova({
callbackOrder: 'reverse'
})
setConfig(options: BackgroundGeolocationConfig): Promise<any> { return; }
/**
* Returns current stationaryLocation if available. null if not
* @returns {Promise<Location>}
*/
@Cordova({
platforms: ['iOS', 'Windows Phone']
})
getStationaryLocation(): Promise<BackgroundGeolocationResponse> { return; }
/**
* Add a stationary-region listener. Whenever the devices enters "stationary-mode",
* your #success callback will be executed with #location param containing #radius of region
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['iOS', 'Windows Phone']
})
onStationary(): Promise<any> { return; }
/**
* Check if location is enabled on the device
* @returns {Promise<number>} Returns a promise with int argument that takes values 0, 1 (true).
*/
@Cordova({
platforms: ['Android']
})
isLocationEnabled(): Promise<number> { return; }
/**
* Display app settings to change permissions
*/
@Cordova({sync: true})
showAppSettings(): void { }
/**
* Display device location settings
*/
@Cordova({sync: true})
showLocationSettings(): void { }
/**
* Method can be used to detect user changes in location services settings.
* If user enable or disable location services then success callback will be executed.
* In case or error (SettingNotFoundException) fail callback will be executed.
* @returns {Promise<boolean>}
*/
@Cordova({
platforms: ['Android']
})
watchLocationMode(): Promise<boolean> { return; }
/**
* Stop watching for location mode changes.
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['Android']
})
stopWatchingLocationMode(): Promise<any> { return; }
/**
* Method will return all stored locations.
* Locations are stored when:
* - config.stopOnTerminate is false and main activity was killed
* by the system
* or
* - option.debug is true
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['Android']
})
getLocations(): Promise<any> { return; }
/**

* Method will return locations, which has not been yet posted to server. NOTE: Locations does contain locationId.

* @returns {Promise<any>}
*/
@Cordova()
getValidLocations(): Promise<any> { return; }
/**
* Delete stored location by given locationId.
* @param locationId {number}
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['Android']
})
deleteLocation(locationId: number): Promise<any> { return; }
/**
* Delete all stored locations.
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['Android']
})
deleteAllLocations(): Promise<any> { return; }
/**
* Normally plugin will handle switching between BACKGROUND and FOREGROUND mode itself.
* Calling switchMode you can override plugin behavior and force plugin to switch into other mode.
*
* In FOREGROUND mode plugin uses iOS local manager to receive locations and behavior is affected by option.desiredAccuracy and option.distanceFilter.
* In BACKGROUND mode plugin uses significant changes and region monitoring to receive locations and uses option.stationaryRadius only.

*
* BackgroundGeolocation.Mode.FOREGROUND
* BackgroundGeolocation.Mode.BACKGROUND

**
* @param modeId {number}
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['iOS']
})
switchMode(modeId: number): Promise<any> { return; }
/**

* Return all logged events. Useful for plugin debugging. Parameter limit limits number of returned entries.

* @see https://github.com/mauron85/cordova-plugin-background-geolocation/tree/v2.2.1#debugging for more information.

*
* @param limit {number} Limits the number of entries

* @returns {Promise<any>}
*/
@Cordova()
getLogEntries(limit: number): Promise<any> { return; }
}
src/@ionic-native/plugins/background-mode/index.ts
+195
View File
@@ -0,0 +1,195 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
/**
* Configurations items that can be updated.
*/
export interface BackgroundModeConfiguration {
/**
* Title of the background task
*/
title?: String;
/**
* The text that scrolls itself on statusbar
*/
ticker?: String;
/**
* Description of background task
*/
text?: String;
/**
* if true plugin will not display a notification. Default is false.
*/
silent?: boolean;
/**
* By default the app will come to foreground when taping on the notification. If false, plugin wont come to foreground when tapped.
*/
resume?: boolean;
}
/**
* @name Background Mode
* @description
* Cordova plugin to prevent the app from going to sleep while in background.
* Requires Cordova plugin: cordova-plugin-background-mode. For more info about plugin, vist: https://github.com/katzer/cordova-plugin-background-mode
*@usage
* ```typescript
* import { BackgroundMode } from '@ionic-native/background-mode';
*
* constructor(private backgroundMode: BackgroundMode) { }
*
* ...
*
* this.backgroundMode.enable();
* ```
*
* @interfaces
* BackgroundModeConfiguration
*/
@Plugin({
pluginName: 'BackgroundMode',
plugin: 'cordova-plugin-background-mode',
pluginRef: 'cordova.plugins.backgroundMode',
repo: 'https://github.com/katzer/cordova-plugin-background-mode',
platforms: ['Android', 'iOS', 'Windows Phone 8']
})
@Injectable()
export class BackgroundMode {
/**
* Enable the background mode.
* Once called, prevents the app from being paused while in background.
*/
@Cordova({
sync: true
})
enable(): void { }
/**
* Disable the background mode.
* Once the background mode has been disabled, the app will be paused when in background.
*/
@Cordova()
disable(): Promise<any> { return; }
/**
* Checks if background mode is enabled or not.
* @returns {boolean} returns a boolean that indicates if the background mode is enabled.
*/
@Cordova({
sync: true
})
isEnabled(): boolean { return; }
/**
* Can be used to get the information if the background mode is active.
* @returns {boolean} returns a boolean that indicates if the background mode is active.
*/
@Cordova({
sync: true
})
isActive(): boolean { return; }
/**
* Override the default title, ticker and text.
* Available only for Android platform.
* @param {Configure} options List of option to configure. See table below
*/
@Cordova({
platforms: ['Android']
})
setDefaults(options?: BackgroundModeConfiguration): Promise<any> { return; }
/**
* Modify the displayed information.
* Available only for Android platform.
* @param {Configure} options Any options you want to update. See table below.
*/
@Cordova({
platforms: ['Android']
})
configure(options?: BackgroundModeConfiguration): Promise<any> { return; }
/**
* Listen for events that the plugin fires. Available events are `enable`, `disable`, `activate`, `deactivate` and `failure`.
* @param event {string} Event name
* @returns {Observable<any>}
*/
@Cordova({
observable: true,
clearFunction: 'un',
clearWithArgs: true
})
on(event: string): Observable<any> { return; }
/**
* Android allows to programmatically move from foreground to background.
*/
@Cordova({
platforms: ['Android'],
sync: true
})
moveToBackground(): void {}
/**
* Android allows to programmatically move from background to foreground.
*/
@Cordova({
platforms: ['Android'],
sync: true
})
moveToForeground(): void {}
/**
* Override the back button on Android to go to background instead of closing the app.
*/
@Cordova({
platforms: ['Android'],
sync: true
})
overrideBackButton(): void {}
/**
* Exclude the app from the recent task list works on Android 5.0+.
*/
@Cordova({
platforms: ['Android'],
sync: true
})
excludeFromTaskList(): void {}
/**
* The method works async instead of isActive() or isEnabled().
*/
@Cordova({
platforms: ['Android']
})
isScreenOff(): Promise<boolean> { return; }
/**
* Turn screen on
*/
@Cordova({
platforms: ['Android'],
sync: true
})
wakeUp(): void {}
/**
* Turn screen on and show app even locked
*/
@Cordova({
platforms: ['Android'],
sync: true
})
unlock(): void {}
}
src/@ionic-native/plugins/backlight/index.ts
+51
View File
@@ -0,0 +1,51 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @beta
* @name Backlight
* @description
* This plugin adds turning on/off the device backlight.
*
* @usage
* ```
* import { Backlight } from '@ionic-native/backlight';
*
* constructor(private backlight: Backlight) { }
*
* ...
*
* // Turn backlight on
* this.backlight.on().then(() => console.log('backlight on'));
*
* // Turn backlight off
* this.backlight.off().then(() => console.log('backlight off'));
*
* ```
*/
@Plugin({
pluginName: 'Backlight',
plugin: 'cordova-plugin-backlight',
pluginRef: 'cordova.plugins.Backlight',
repo: 'https://github.com/mebibou/cordova-plugin-backlight',
platforms: ['Android']
})
@Injectable()
export class Backlight {
/**
* This function turns backlight on
* @return {Promise<any>} Returns a promise that resolves when the backlight is on
*/
@Cordova()
on(): Promise<any> { return; }
/**
* This function turns backlight off
* @return {Promise<any>} Returns a promise that resolves when the backlight is off
*/
@Cordova()
off(): Promise<any> { return; }
}
src/@ionic-native/plugins/badge/index.ts
+87
View File
@@ -0,0 +1,87 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Badge
* @description
* The essential purpose of badge numbers is to enable an application to inform its users that it has something for them — for example, unread messages — when the application isn’t running in the foreground.
*
* Requires Cordova plugin: cordova-plugin-badge. For more info, please see the [Badge plugin docs](https://github.com/katzer/cordova-plugin-badge).
*
* @usage
* ```typescript
* import { Badge } from '@ionic-native/badge';
*
* constructor(private badge: Badge) { }
*
* ...
*
* this.badge.set(10);
* this.badge.increase(1);
* this.badge.clear();
* ```
*/
@Plugin({
pluginName: 'Badge',
plugin: 'cordova-plugin-badge',
pluginRef: 'cordova.plugins.notification.badge',
repo: 'https://github.com/katzer/cordova-plugin-badge',
platforms: ['Android', 'iOS', 'Browser', 'Windows', 'Amazon FireOS', 'Windows Phone 8']
})
@Injectable()
export class Badge {
/**
* Clear the badge of the app icon.
* @returns {Promise<boolean>}
*/
@Cordova()
clear(): Promise<boolean> { return; }
/**
* Set the badge of the app icon.
* @param {number} badgeNumber The new badge number.
* @returns {Promise<any>}
*/
@Cordova()
set(badgeNumber: number): Promise<any> { return; }
/**
* Get the badge of the app icon.
* @returns {Promise<any>}
*/
@Cordova()
get(): Promise<any> { return; }
/**
* Increase the badge number.
* @param {number} increaseBy Count to add to the current badge number
* @returns {Promise<any>}
*/
@Cordova()
increase(increaseBy: number): Promise<any> { return; }
/**
* Decrease the badge number.
* @param {number} decreaseBy Count to subtract from the current badge number
* @returns {Promise<any>}
*/
@Cordova()
decrease(decreaseBy: number): Promise<any> { return; }
/**
* Determine if the app has permission to show badges.
* @returns {Promise<any>}
*/
@Cordova()
hasPermission(): Promise<any> { return; }
/**
* Register permission to set badge notifications
* @returns {Promise<any>}
*/
@Cordova()
registerPermission(): Promise<any> { return; }
}
src/@ionic-native/plugins/barcode-scanner/index.ts
+126
View File
@@ -0,0 +1,126 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface BarcodeScannerOptions {
/**
* Prefer front camera. Supported on iOS and Android.
*/
preferFrontCamera?: boolean;
/**
* Show flip camera button. Supported on iOS and Android.
*/
showFlipCameraButton?: boolean;
/**
* Show torch button. Supported on iOS and Android.
*/
showTorchButton?: boolean;
/**
* Disable animations. Supported on iOS only.
*/
disableAnimations?: boolean;
/**
* Disable success beep. Supported on iOS only.
*/
disableSuccessBeep?: boolean;
/**
* Prompt text. Supported on Android only.
*/
prompt?: string;
/**
* Formats separated by commas. Defaults to all formats except `PDF_417` and `RSS_EXPANDED`.
*/
formats?: string;
/**
* Orientation. Supported on Android only. Can be set to `portrait` or `landscape`. Defaults to none so the user can rotate the phone and pick an orientation.
*/
orientation?: string;
/**
* Launch with the torch switched on (if available). Supported on Android only.
*/
torchOn?: boolean;
/**
* Display scanned text for X ms. 0 suppresses it entirely, default 1500. Supported on Android only.
*/
resultDisplayDuration?: number;
}
/**
* @name Barcode Scanner
* @description
* The Barcode Scanner Plugin opens a camera view and automatically scans a barcode, returning the data back to you.
*
* Requires Cordova plugin: `phonegap-plugin-barcodescanner`. For more info, please see the [BarcodeScanner plugin docs](https://github.com/phonegap/phonegap-plugin-barcodescanner).
*
* @usage
* ```typescript
* import { BarcodeScanner } from '@ionic-native/barcode-scanner';
*
* constructor(private barcodeScanner: BarcodeScanner) { }
*
* ...
*
*
* this.barcodeScanner.scan().then((barcodeData) => {
* // Success! Barcode data is here
* }, (err) => {
* // An error occurred
* });
* ```
* @interfaces
* BarcodeScannerOptions
*/
@Plugin({
pluginName: 'BarcodeScanner',
plugin: 'phonegap-plugin-barcodescanner',
pluginRef: 'cordova.plugins.barcodeScanner',
repo: 'https://github.com/phonegap/phonegap-plugin-barcodescanner',
platforms: ['Android', 'iOS', 'Windows Phone 8', 'Windows 10', 'Windows 8', 'BlackBerry 10', 'Browser']
})
@Injectable()
export class BarcodeScanner {
Encode: {
TEXT_TYPE: string;
EMAIL_TYPE: string;
PHONE_TYPE: string;
SMS_TYPE: string;
} = {
TEXT_TYPE: 'TEXT_TYPE',
EMAIL_TYPE: 'EMAIL_TYPE',
PHONE_TYPE: 'PHONE_TYPE',
SMS_TYPE: 'SMS_TYPE'
};
/**
* Open the barcode scanner.
* @param options {BarcodeScannerOptions} Optional options to pass to the scanner
* @returns {Promise<any>} Returns a Promise that resolves with scanner data, or rejects with an error.
*/
@Cordova({
callbackOrder: 'reverse'
})
scan(options?: BarcodeScannerOptions): Promise<any> { return; }
/**
* Encodes data into a barcode.
* NOTE: not well supported on Android
* @param type {string} Type of encoding
* @param data {any} Data to encode
* @returns {Promise<any>}
*/
@Cordova()
encode(type: string, data: any): Promise<any> { return; }
}
src/@ionic-native/plugins/base64-to-gallery/index.ts
+47
View File
@@ -0,0 +1,47 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Base64 To Gallery
* @description This plugin allows you to save base64 data as a png image into the device
* @usage
* ```typescript
* import { Base64ToGallery } from '@ionic-native/base64-to-gallery';
*
* constructor(private base64ToGallery: Base64ToGallery) { }
*
*
* ...
*
*
* this.base64ToGallery.base64ToGallery(base64Data, { prefix: '_img' }).then(
* res => console.log('Saved image to gallery ', res),
* err => console.log('Error saving image to gallery ', err)
* );
* ```
*/
@Plugin({
pluginName: 'Base64ToGallery',
plugin: 'cordova-base64-to-gallery',
pluginRef: 'cordova',
repo: 'https://github.com/Nexxa/cordova-base64-to-gallery',
platforms: ['Android', 'iOS', 'Windows Phone 8']
})
@Injectable()
export class Base64ToGallery {
/**
* Converts a base64 string to an image file in the device gallery
* @param {string} data The actual base64 string that you want to save
* @param {any} options (optional) An object with properties: prefix: string, mediaScanner: boolean. Prefix will be prepended to the filename. If true, mediaScanner runs Media Scanner on Android and saves to Camera Roll on iOS; if false, saves to Library folder on iOS.
* @returns {Promise<any>} returns a promise that resolves when the image is saved.
*/
@Cordova({
successIndex: 2,
errorIndex: 3
})
base64ToGallery(data: string, options?: {prefix?: string; mediaScanner?: boolean}): Promise<any> {
return;
}
}
src/@ionic-native/plugins/battery-status/index.ts
+87
View File
@@ -0,0 +1,87 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export interface BatteryStatusResponse {
/**
* The battery charge percentage
*/
level: number;
/**
* A boolean that indicates whether the device is plugged in
*/
isPlugged: boolean;
}
/**
* @name Battery Status
* @description
* Requires Cordova plugin: cordova-plugin-batterystatus. For more info, please see the [BatteryStatus plugin docs](https://github.com/apache/cordova-plugin-battery-status).
*
* @usage
* ```typescript
* import { BatteryStatus } from '@ionic-native/battery-status';
*
* constructor(private batteryStatus: BatteryStatus) { }
*
* ...
*
*
* // watch change in battery status
* let subscription = this.batteryStatus.onChange().subscribe(
* (status: StatusObject) => {
* console.log(status.level, status.isPlugged);
* }
* );
*
* // stop watch
* subscription.unsubscribe();
*
* ```
* @interfaces
* BatteryStatusResponse
*/
@Plugin({
pluginName: 'BatteryStatus',
plugin: 'cordova-plugin-battery-status',
pluginRef: 'navigator.battery',
repo: 'https://github.com/apache/cordova-plugin-battery-status',
platforms: ['Amazon Fire OS', 'iOS', 'Android', 'BlackBerry 10', 'Windows Phone 7', 'Windows Phone 8', 'Windows', 'Firefox OS', 'Browser']
})
@Injectable()
export class BatteryStatus {
/**
* Watch the change in battery level
* @returns {Observable<BatteryStatusResponse>} Returns an observable that pushes a status object
*/
@Cordova({
eventObservable: true,
event: 'batterystatus'
})
onChange(): Observable<BatteryStatusResponse> { return; }
/**
* Watch when the battery level goes low
* @returns {Observable<BatteryStatusResponse>} Returns an observable that pushes a status object
*/
@Cordova({
eventObservable: true,
event: 'batterylow'
})
onLow(): Observable<BatteryStatusResponse> { return; }
/**
* Watch when the battery level goes to critial
* @returns {Observable<BatteryStatusResponse>} Returns an observable that pushes a status object
*/
@Cordova({
eventObservable: true,
event: 'batterycritical'
})
onCritical(): Observable<BatteryStatusResponse> { return; }
}
src/@ionic-native/plugins/ble/index.ts
+447
View File
@@ -0,0 +1,447 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
/**
* @name BLE
* @description
* This plugin enables communication between a phone and Bluetooth Low Energy (BLE) peripherals.
*
* The plugin provides a simple JavaScript API for iOS and Android.
*
* - Scan for peripherals
* - Connect to a peripheral
* - Read the value of a characteristic
* - Write new value to a characteristic
* - Get notified when characteristic's value changes
*
* Advertising information is returned when scanning for peripherals. Service, characteristic, and property info is returned when connecting to a peripheral. All access is via service and characteristic UUIDs. The plugin manages handles internally.
*
* Simultaneous connections to multiple peripherals are supported.
*
* @usage
*
* ```typescript
*
* import { BLE } from '@ionic-native/ble';
*
* constructor(private ble: BLE) { }
*
* ```
*
* ## Peripheral Data
*
* Peripheral Data is passed to the success callback when scanning and connecting. Limited data is passed when scanning.
*
* ```typescript
* {
* "name": "Battery Demo",
* "id": "20:FF:D0:FF:D1:C0",
* "advertising": [2,1,6,3,3,15,24,8,9,66,97,116,116,101,114,121],
* "rssi": -55
* }
* ```
* After connecting, the peripheral object also includes service, characteristic and descriptor information.
*
* ```typescript
* {
* "name": "Battery Demo",
* "id": "20:FF:D0:FF:D1:C0",
* "advertising": [2,1,6,3,3,15,24,8,9,66,97,116,116,101,114,121],
* "rssi": -55,
* "services": [
* "1800",
* "1801",
* "180f"
* ],
* "characteristics": [
* {
* "service": "1800",
* "characteristic": "2a00",
* "properties": [
* "Read"
* ]
* },
* {
* "service": "1800",
* "characteristic": "2a01",
* "properties": [
* "Read"
* ]
* },
* {
* "service": "1801",
* "characteristic": "2a05",
* "properties": [
* "Read"
* ]
* },
* {
* "service": "180f",
* "characteristic": "2a19",
* "properties": [
* "Read"
* ],
* "descriptors": [
* {
* "uuid": "2901"
* },
* {
* "uuid": "2904"
* }
* ]
* }
* ]
* }
* ```
*
* ## Advertising Data
* Bluetooth advertising data is returned in when scanning for devices. The format format varies depending on your platform. On Android advertising data will be the raw advertising bytes. iOS does not allow access to raw advertising data, so a dictionary of data is returned.
*
* The advertising information for both Android and iOS appears to be a combination of advertising data and scan response data.
*
* ### Android
*
* ```typescript
* {
* "name": "demo",
* "id": "00:1A:7D:DA:71:13",
* "advertising": ArrayBuffer,
* "rssi": -37
* }
* ```
*
* Convert the advertising info to a Uint8Array for processing. `var adData = new Uint8Array(peripheral.advertising)`
*
* ### iOS
*
* Note that iOS uses the string value of the constants for the [Advertisement Data Retrieval Keys](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBCentralManagerDelegate_Protocol/index.html#//apple_ref/doc/constant_group/Advertisement_Data_Retrieval_Keys). This will likely change in the future.
*
* ```typescript
* {
* "name": "demo",
* "id": "D8479A4F-7517-BCD3-91B5-3302B2F81802",
* "advertising": {
* "kCBAdvDataChannel": 37,
* "kCBAdvDataServiceData": {
* "FED8": {
* "byteLength": 7 // data not shown
* }
* },
* "kCBAdvDataLocalName": "demo",
* "kCBAdvDataServiceUUIDs": ["FED8"],
* "kCBAdvDataManufacturerData": {
* "byteLength": 7 // data not shown
* },
* "kCBAdvDataTxPowerLevel": 32,
* "kCBAdvDataIsConnectable": true
* },
* "rssi": -53
* }
* ```
*
* ## Typed Arrays
*
* This plugin uses typed Arrays or ArrayBuffers for sending and receiving data.
*
* This means that you need convert your data to ArrayBuffers before sending and from ArrayBuffers when receiving.
*
* ```typescript
* // ASCII only
* function stringToBytes(string) {
* var array = new Uint8Array(string.length);
* for (var i = 0, l = string.length; i < l; i++) {
* array[i] = string.charCodeAt(i);
* }
* return array.buffer;
* }
*
* // ASCII only
* function bytesToString(buffer) {
* return String.fromCharCode.apply(null, new Uint8Array(buffer));
* }
* ```
* You can read more about typed arrays in these articles on [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays) and [HTML5 Rocks](http://www.html5rocks.com/en/tutorials/webgl/typed_arrays/).
*
* ## UUIDs
*
* UUIDs are always strings and not numbers. Some 16-bit UUIDs, such as '2220' look like integers, but they're not. (The integer 2220 is 0x8AC in hex.) This isn't a problem with 128 bit UUIDs since they look like strings 82b9e6e1-593a-456f-be9b-9215160ebcac. All 16-bit UUIDs should also be passed to methods as strings.
*
*/
@Plugin({
pluginName: 'BLE',
plugin: 'cordova-plugin-ble-central',
pluginRef: 'ble',
repo: 'https://github.com/don/cordova-plugin-ble-central',
platforms: ['iOS', 'Android']
})
@Injectable()
export class BLE {
/**
* Scan and discover BLE peripherals for the specified amount of time.
*
* @usage
* ```
* BLE.scan([], 5).subscribe(device => {
* console.log(JSON.stringify(device));
* });
* ```
* @param {string[]} services List of service UUIDs to discover, or `[]` to find all devices
* @param {number} seconds Number of seconds to run discovery
* @returns {Observable<any>} Returns an Observable that notifies of each peripheral that is discovered during the specified time.
*/
@Cordova({
observable: true
})
scan(services: string[], seconds: number): Observable<any> { return; }
/**
* Scan and discover BLE peripherals until `stopScan` is called.
*
* @usage
* ```
* BLE.startScan([]).subscribe(device => {
* console.log(JSON.stringify(device));
* });
*
* setTimeout(() => {
* BLE.stopScan();
* }, 5000);
* ```
* @param {string[]} services List of service UUIDs to discover, or `[]` to find all devices
* @returns {Observable<any>} Returns an Observable that notifies of each peripheral discovered.
*/
@Cordova({
observable: true,
clearFunction: 'stopScan',
clearWithArgs: false
})
startScan(services: string[]): Observable<any> { return; }
/**
* Scans for BLE devices. This function operates similarly to the `startScan` function, but allows you to specify extra options (like allowing duplicate device reports).
* @param {string[]} services List of service UUIDs to discover, or `[]` to find all devices
* @param options {any}
* @returns {Observable<any>} Returns an Observable that notifies of each peripheral discovered.
*/
@Cordova({
observable: true,
clearFunction: 'stopScan',
clearWithArgs: false
})
startScanWithOptions(services: string[], options: {reportDuplicates?: boolean} | any): Observable<any> { return; }
/**
* Stop a scan started by `startScan`.
*
* @usage
* ```
* BLE.startScan([]).subscribe(device => {
* console.log(JSON.stringify(device));
* });
* setTimeout(() => {
* BLE.stopScan().then(() => { console.log('scan stopped'); });
* }, 5000);
* ```
* @return returns a Promise.
*/
@Cordova()
stopScan(): Promise<any> { return; }
/**
* Connect to a peripheral.
* @usage
* ```
* BLE.connect('12:34:56:78:9A:BC').subscribe(peripheralData => {
* console.log(peripheralData);
* },
* peripheralData => {
* console.log('disconnected');
* });
* ```
* @param deviceId {string} UUID or MAC address of the peripheral
* @return Returns an Observable that notifies of connect/disconnect.
*/
@Cordova({
observable: true,
clearFunction: 'disconnect',
clearWithArgs: true
})
connect(deviceId: string): Observable<any> { return; }
/**
* Disconnect from a peripheral.
* @usage
* ```
* BLE.disconnect('12:34:56:78:9A:BC').then(() => {
* console.log('Disconnected');
* });
* ```
* @param deviceId {string} UUID or MAC address of the peripheral
* @return Returns a Promise
*/
@Cordova()
disconnect(deviceId: string): Promise<any> { return; }
/**
* Read the value of a characteristic.
*
* @param {string} deviceId UUID or MAC address of the peripheral
* @param {string} serviceUUID UUID of the BLE service
* @param {string} characteristicUUID UUID of the BLE characteristic
* @return Returns a Promise
*/
@Cordova()
read(
deviceId: string,
serviceUUID: string,
characteristicUUID: string
): Promise<any> { return; };
/**
* Write the value of a characteristic.
* @usage
* ```
* // send 1 byte to switch a light on
* var data = new Uint8Array(1);
* data[0] = 1;
* BLE.write(device_id, "FF10", "FF11", data.buffer);
*
* // send a 3 byte value with RGB color
* var data = new Uint8Array(3);
* data[0] = 0xFF; // red
* data[0] = 0x00; // green
* data[0] = 0xFF; // blue
* BLE.write(device_id, "ccc0", "ccc1", data.buffer);
*
* // send a 32 bit integer
* var data = new Uint32Array(1);
* data[0] = counterInput.value;
* BLE.write(device_id, SERVICE, CHARACTERISTIC, data.buffer);
*
* ```
* @param {string} deviceId UUID or MAC address of the peripheral
* @param {string} serviceUUID UUID of the BLE service
* @param {string} characteristicUUID UUID of the BLE characteristic
* @param {ArrayBuffer} value Data to write to the characteristic, as an ArrayBuffer.
* @return Returns a Promise
*/
@Cordova()
write(
deviceId: string,
serviceUUID: string,
characteristicUUID: string,
value: ArrayBuffer
): Promise<any> { return; }
/**
* Write the value of a characteristic without waiting for confirmation from the peripheral.
*
* @param {string} deviceId UUID or MAC address of the peripheral
* @param {string} serviceUUID UUID of the BLE service
* @param {string} characteristicUUID UUID of the BLE characteristic
* @param {ArrayBuffer} value Data to write to the characteristic, as an ArrayBuffer.
* @return Returns a Promise
*/
@Cordova()
writeWithoutResponse(
deviceId: string,
serviceUUID: string,
characteristicUUID: string,
value: ArrayBuffer
): Promise<any> { return; }
/**
* Register to be notified when the value of a characteristic changes.
*
* @usage
* ```
* BLE.startNotification(device_id, "FF10", "FF11").subscribe(buffer => {
* console.log(String.fromCharCode.apply(null, new Uint8Array(buffer));
* });
* ```
*
* @param {string} deviceId UUID or MAC address of the peripheral
* @param {string} serviceUUID UUID of the BLE service
* @param {string} characteristicUUID UUID of the BLE characteristic
* @return Returns an Observable that notifies of characteristic changes.
*/
@Cordova({
observable: true,
clearFunction: 'stopNotification',
clearWithArgs: true
})
startNotification(
deviceId: string,
serviceUUID: string,
characteristicUUID: string
): Observable<any> { return; }
/**
* Stop being notified when the value of a characteristic changes.
*
* @param {string} deviceId UUID or MAC address of the peripheral
* @param {string} serviceUUID UUID of the BLE service
* @param {string} characteristicUUID UUID of the BLE characteristic
* @returns {Promise<any>}
*/
@Cordova()
stopNotification(
deviceId: string,
serviceUUID: string,
characteristicUUID: string
): Promise<any> { return; }
/**
* Report the connection status.
*
* @usage
* ```
* BLE.isConnected('FFCA0B09-CB1D-4DC0-A1EF-31AFD3EDFB53').then(
* () => { console.log('connected'); },
* () => { console.log('not connected'); }
* );
* ```
* @param {string} deviceId UUID or MAC address of the peripheral
* @returns {Promise<any>}
*/
@Cordova()
isConnected(deviceId: string): Promise<any> { return; }
/**
* Report if bluetooth is enabled.
*
* @returns {Promise<void>} Returns a Promise that resolves if Bluetooth is enabled, and rejects if disabled.
*/
@Cordova()
isEnabled(): Promise<void> { return; }
/**
* Open System Bluetooth settings (Android only).
*
* @returns {Promise<any>}
*/
@Cordova()
showBluetoothSettings(): Promise<any> { return; }
/**
* Enable Bluetooth on the device (Android only).
*
* @returns {Promise<any>}
*/
@Cordova()
enable(): Promise<any> { return; }
/**
* Read the RSSI value on the device connection.
*
* @param {string} deviceId UUID or MAC address of the peripheral
*
*@returns {Promise<any>}
*/
@Cordova()
static readRSSI(
deviceId: string,
): Promise<any> { return; }
}
src/@ionic-native/plugins/bluetooth-serial/index.ts
+237
View File
@@ -0,0 +1,237 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
/**
* @name Bluetooth Serial
* @description This plugin enables serial communication over Bluetooth. It was written for communicating between Android or iOS and an Arduino.
* @usage
* ```typescript
* import { BluetoothSerial } from '@ionic-native/bluetooth-serial';
*
* constructor(private bluetoothSerial: BluetoothSerial) { }
*
*
* // Write a string
* this.bluetoothSerial.write("hello world").then(success, failure);
*
* // Array of int or bytes
* this.bluetoothSerial.write([186, 220, 222]).then(success, failure);
*
* // Typed Array
* var data = new Uint8Array(4);
* data[0] = 0x41;
* data[1] = 0x42;
* data[2] = 0x43;
* data[3] = 0x44;
* this.bluetoothSerial.write(data).then(success, failure);
*
* // Array Buffer
* this.bluetoothSerial.write(data.buffer).then(success, failure);
* ```
*/
@Plugin({
pluginName: 'BluetoothSerial',
repo: 'https://github.com/don/BluetoothSerial',
plugin: 'cordova-plugin-bluetooth-serial',
pluginRef: 'bluetoothSerial',
platforms: ['Android', 'iOS', 'Windows Phone', 'Browser']
})
@Injectable()
export class BluetoothSerial {
/**
* Connect to a Bluetooth device
* @param {string} macAddress_or_uuid Identifier of the remote device
* @returns {Observable<any>} Subscribe to connect, unsubscribe to disconnect.
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone'],
observable: true,
clearFunction: 'disconnect'
})
connect(macAddress_or_uuid: string): Observable<any> { return; }
/**
* Connect insecurely to a Bluetooth device
* @param {string} macAddress Identifier of the remote device
* @returns {Observable<any>} Subscribe to connect, unsubscribe to disconnect.
*/
@Cordova({
platforms: ['Android'],
observable: true,
clearFunction: 'disconnect'
})
connectInsecure(macAddress: string): Observable<any> { return; }
/**
* Disconnect from the connected device
* @returns {Promise<any>}
*/
@Cordova()
disconnect(): Promise<any> { return; }
/**
* Writes data to the serial port
* @param {any} data ArrayBuffer of data
* @returns {Promise<any>} returns a promise when data has been written
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
write(data: any): Promise<any> { return; }
/**
* Gets the number of bytes of data available
* @returns {Promise<any>} returns a promise that contains the available bytes
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
}) available(): Promise<any> { return; }
/**
* Reads data from the buffer
* @returns {Promise<any>} returns a promise with data from the buffer
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
read(): Promise<any> { return; }
/**
* Reads data from the buffer until it reaches a delimiter
* @param {string} delimiter string that you want to search until
* @returns {Promise<any>} returns a promise
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
readUntil(delimiter: string): Promise<any> { return; }
/**
* Subscribe to be notified when data is received
* @param {string} delimiter the string you want to watch for
* @returns {Observable<any>} returns an observable.
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone'],
observable: true,
clearFunction: 'unsubscribe'
})
subscribe(delimiter: string): Observable<any> { return; }
/**
* Subscribe to be notified when data is received
* @returns {Observable<any>} returns an observable
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone'],
observable: true,
clearFunction: 'unsubscribeRawData'
})
subscribeRawData(): Observable<any> { return; }
/**
* Clears data in buffer
* @returns {Promise<any>} returns a promise when completed
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
clear(): Promise<any> { return; }
/**
* Lists bonded devices
* @returns {Promise<any>} returns a promise
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
list(): Promise<any> { return; }
/**
* Reports if bluetooth is enabled
* @returns {Promise<any>} returns a promise
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
isEnabled(): Promise<any> { return; }
/**
* Reports the connection status
* @returns {Promise<any>} returns a promise
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
isConnected(): Promise<any> { return; }
/**
* Reads the RSSI from the connected peripheral
* @returns {Promise<any>} returns a promise
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
readRSSI(): Promise<any> { return; }
/**
* Show the Bluetooth settings on the device
* @returns {Promise<any>} returns a promise
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
showBluetoothSettings(): Promise<any> { return; }
/**
* Enable Bluetooth on the device
* @returns {Promise<any>} returns a promise
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
enable(): Promise<any> { return; }
/**
* Discover unpaired devices
* @returns {Promise<any>} returns a promise
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone']
})
discoverUnpaired(): Promise<any> { return; }
/**
* Subscribe to be notified on Bluetooth device discovery. Discovery process must be initiated with the `discoverUnpaired` function.
* @returns {Observable<any>} Returns an observable
*/
@Cordova({
platforms: ['Android', 'iOS', 'Windows Phone'],
observable: true,
clearFunction: 'clearDeviceDiscoveredListener'
})
setDeviceDiscoveredListener(): Observable<any> { return; }
/**
* Sets the human readable device name that is broadcasted to other devices
* @param {string} newName Desired name of device
*/
@Cordova({
platforms: ['Android'],
sync: true
})
setName(newName: string): void { }
/**
* Makes the device discoverable by other devices
* @param {number} discoverableDuration Desired number of seconds device should be discoverable for
*/
@Cordova({
platforms: ['Android'],
sync: true
})
setDiscoverable(discoverableDuration: number): void { }
}
src/@ionic-native/plugins/brightness/index.ts
+58
View File
@@ -0,0 +1,58 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Brightness
* @description
* The Brightness plugin let you control the display brightness of your device.
*
* Requires Cordova plugin: `cordova-plugin-brightness`. For more info, please see the [Brightness plugin docs](https://github.com/mgcrea/cordova-plugin-brightness).
*
* @usage
* ```typescript
* import { Brightness } from '@ionic-native/brightness';
*
* constructor(private brightness: Brightness) { }
*
* ...
*
* let brightnessValue: number = 0.8;
* this.brightness.setBrightness(brightnessValue);
* ```
*
*/
@Plugin({
pluginName: 'Brightness',
plugin: 'cordova-plugin-brightness',
pluginRef: 'cordova.plugins.brightness',
repo: 'https://github.com/mgcrea/cordova-plugin-brightness',
platforms: ['Android', 'iOS']
})
@Injectable()
export class Brightness {
/**
* Sets the brightness of the display.
*
* @param {value} Floating number between 0 and 1 in which case 1 means 100% brightness and 0 means 0% brightness.
* @returns {Promise<any>} Returns a Promise that resolves if setting brightness was successful.
*/
@Cordova()
setBrightness(value: number): Promise<any> { return; }
/**
* Reads the current brightness of the device display.
*
* @returns {Promise<any>} Returns a Promise that resolves with the
* brightness value of the device display (floating number between 0 and 1).
*/
@Cordova()
getBrightness(): Promise<any> { return; }
/**
* Keeps the screen on. Prevents the device from setting the screen to sleep.
*/
@Cordova()
setKeepScreenOn(value: boolean): void { }
}
src/@ionic-native/plugins/broadcaster/index.ts
+57
View File
@@ -0,0 +1,57 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
/**
* @name Broadcaster
* @description
* This plugin adds exchanging events between native code and your app.
*
* @usage
* ```
* import { Broadcaster } from '@ionic-native/broadcaster';
*
* constructor(private broadcaster: Broadcaster) { }
*
* ...
*
* // Listen to events from Native
* this.broadcaster.addEventListener('eventName').then((event) => console.log(event));
*
* // Send event to Native
* this.broadcaster.fireNativeEvent('eventName', {}).then(() => console.log('success'));
*
* ```
*/
@Plugin({
pluginName: 'Broadcaster',
plugin: 'cordova-plugin-broadcaster',
pluginRef: 'broadcaster',
repo: 'https://github.com/bsorrentino/cordova-broadcaster',
platforms: ['Android', 'iOS']
})
@Injectable()
export class Broadcaster {
/**
* This function listen to an event sent from the native code
* @param eventName {string}
* @return {Observable<any>} Returns an observable to watch when an event is received
*/
@Cordova({
observable: true,
clearFunction: 'removeEventListener',
clearWithArgs: true
})
addEventListener(eventName: string): Observable<any> { return; }
/**
* This function sends data to the native code
* @param eventName {string}
* @param eventData {any}
* @return {Promise<any>} Returns a promise that resolves when an event is successfully fired
*/
@Cordova()
fireNativeEvent(eventName: string, eventData: any): Promise<any> { return; }
}
src/@ionic-native/plugins/browser-tab/index.ts
+66
View File
@@ -0,0 +1,66 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Injectable } from '@angular/core';
/**
* @name Browser Tab
* @description
* This plugin provides an interface to in-app browser tabs that exist on some mobile platforms, specifically [Custom Tabs](http://developer.android.com/tools/support-library/features.html#custom-tabs) on Android (including the [Chrome Custom Tabs](https://developer.chrome.com/multidevice/android/customtabs) implementation), and [SFSafariViewController](https://developer.apple.com/library/ios/documentation/SafariServices/Reference/SFSafariViewController_Ref/) on iOS.
*
* @usage
* ```
* import { BrowserTab } from '@ionic-native/browser-tab';
*
* constructor(private browserTab: BrowserTab) {
*
* browserTab.isAvailable()
* .then((isAvailable: boolean) => {
*
* if (isAvailable) {
*
* browserTab.open('https://ionic.io');
*
* } else {
*
* // open URL with InAppBrowser instead or SafariViewController
*
* }
*
* });
*
*
* }
*
* ```
*/
@Plugin({
pluginName: 'BrowserTab',
plugin: 'cordova-plugin-browsertab',
pluginRef: 'cordova.plugins.browsertab',
repo: 'https://github.com/google/cordova-plugin-browsertab',
platforms: ['Android', 'iOS']
})
@Injectable()
export class BrowserTab {
/**
* Check if BrowserTab option is available
* @return {Promise<any>} Returns a promise that resolves when check is successful and returns true or false
*/
@Cordova()
isAvailable(): Promise<any> { return; }
/**
* Opens the provided URL using a browser tab
* @param {string} url The URL you want to open
* @return {Promise<any>} Returns a promise that resolves when check open was successful
*/
@Cordova()
openUrl(url: string): Promise<any> { return; }
/**
* Closes browser tab
* @return {Promise<any>} Returns a promise that resolves when close was finished
*/
@Cordova()
close(): Promise<any> { return; }
}
src/@ionic-native/plugins/calendar/index.ts
+424
View File
@@ -0,0 +1,424 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface CalendarOptions {
/**
* Id
*/
id?: string;
/**
*
*/
firstReminderMinutes?: number;
/**
*
*/
secondReminderMinutes?: number;
/**
* Recurrence. Can be set to `daily`, `weekly`, `monthly` or `yearly`
*/
recurrence?: string;
/**
* Recurrence interval. Valid only when `recurrence` option is set.
*/
recurrenceInterval?: number;
/**
* Recurrence end date. Valid only when `recurrence` option is set.
*/
recurrenceEndDate?: Date;
/**
* Calendar name. Ths is supported by `iOS` only.
*/
calendarName?: string;
/**
* Calendar id
*/
calendarId?: number;
/**
* URL
*/
url?: string;
}
/**
* @name Calendar
* @description
* This plugin allows you to add events to the Calendar of the mobile device.
*
* Requires Cordova plugin: `cordova-plugin-calendar`. For more info, please see the [Calendar plugin docs](https://github.com/EddyVerbruggen/Calendar-PhoneGap-Plugin).
*
*
* @usage
* ```
* import {Calendar} from '@ionic-native/calendar';
*
* constructor(private calendar: Calendar) { }
*
*
* this.calendar.createCalendar('MyCalendar').then(
* (msg) => { console.log(msg); },
* (err) => { console.log(err); }
* );
* ```
* @interfaces
* CalendarOptions
*/
@Plugin({
pluginName: 'Calendar',
plugin: 'cordova-plugin-calendar',
pluginRef: 'plugins.calendar',
repo: 'https://github.com/EddyVerbruggen/Calendar-PhoneGap-Plugin',
platforms: ['Android', 'iOS']
})
@Injectable()
export class Calendar {
/**
* This function checks if we have permission to read/write from/to the calendar.
* The promise will resolve with `true` when:
* - You're running on iOS, or
* - You're targetting API level lower than 23, or
* - You're using Android < 6, or
* - You've already granted permission
*
* If this returns false, you should call the `requestReadWritePermission` function
* @returns {Promise<boolean>}
*/
@Cordova()
hasReadWritePermission(): Promise<boolean> { return; }
/**
* Check if we have read permission
* @returns {Promise<boolean>}
*/
@Cordova()
hasReadPermission(): Promise<boolean> { return; }
/**
* Check if we have write permission
* @returns {Promise<boolean>}
*/
@Cordova()
hasWritePermission(): Promise<boolean> { return; }
/**
* Request write permission
* @returns {Promise<any>}
*/
@Cordova()
requestWritePermission(): Promise<any> { return; }
/**
* Request read permission
* @returns {Promise<any>}
*/
@Cordova()
requestReadPermission(): Promise<any> { return; }
/**
* Requests read/write permissions
* @returns {Promise<any>}
*/
@Cordova()
requestReadWritePermission(): Promise<any> { return; }
/**
* Create a calendar. (iOS only)
*
* @param {string | Object} nameOrOptions either a string name or a options object. If string, provide the calendar name. IF an object, provide a calendar name as a string and a calendar color in hex format as a string
* @returns {Promise<any>} Returns a Promise
*/
@Cordova()
createCalendar(nameOrOptions: string | any): Promise<any> { return; }
/**
* Delete a calendar. (iOS only)
* @param {string} name Name of the calendar to delete.
* @returns {Promise<any>} Returns a Promise
*/
@Cordova()
deleteCalendar(name: string): Promise<any> { return; }
/**
* Returns the default calendar options.
*
* @return {CalendarOptions} Returns an object with the default calendar options
*/
@Cordova({
sync: true
})
getCalendarOptions(): CalendarOptions { return; }
/**
* Silently create an event.
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @returns {Promise<any>} Returns a Promise
*/
@Cordova()
createEvent(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date
): Promise<any> { return; }
/**
* Silently create an event with additional options.
*
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @param {CalendarOptions} [options] Additional options, see `getCalendarOptions`
* @returns {Promise<any>} Returns a Promise
*/
@Cordova()
createEventWithOptions(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date,
options?: CalendarOptions
): Promise<any> { return; }
/**
* Interactively create an event.
*
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @returns {Promise<any>} Returns a Promise
*/
@Cordova()
createEventInteractively(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date
): Promise<any> { return; }
/**
* Interactively create an event with additional options.
*
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @param {CalendarOptions} [options] Additional options, see `getCalendarOptions`
* @returns {Promise<any>}
*/
@Cordova()
createEventInteractivelyWithOptions(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date,
options?: CalendarOptions
): Promise<any> { return; }
/**
* Find an event.
*
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @returns {Promise<any>}
*/
@Cordova()
findEvent(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date
): Promise<any> { return; }
/**
* Find an event with additional options.
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @param {CalendarOptions} [options] Additional options, see `getCalendarOptions`
* @returns {Promise<any>} Returns a Promise that resolves with the event, or rejects with an error.
*/
@Cordova()
findEventWithOptions(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date,
options?: CalendarOptions
): Promise<any> { return; }
/**
* Find a list of events within the specified date range. (Android only)
*
* @param {Date} [startDate] The start date
* @param {Date} [endDate] The end date
* @returns {Promise<any>} Returns a Promise that resolves with the list of events, or rejects with an error.
*/
@Cordova({
platforms: ['Android']
})
listEventsInRange(startDate: Date, endDate: Date): Promise<any> { return; }
/**
* Get a list of all calendars.
* @returns {Promise<any>} A Promise that resolves with the list of calendars, or rejects with an error.
*/
@Cordova()
listCalendars(): Promise<any> { return; }
/**
* Get a list of all future events in the specified calendar. (iOS only)
* @returns {Promise<any>} Returns a Promise that resolves with the list of events, or rejects with an error.
*/
@Cordova({
platforms: ['iOS']
})
findAllEventsInNamedCalendar(calendarName: string): Promise<any> { return; }
/**
* Modify an event. (iOS only)
*
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @param {string} [newTitle] The new event title
* @param {string} [newLocation] The new event location
* @param {string} [newNotes] The new event notes
* @param {Date} [newStartDate] The new event start date
* @param {Date} [newEndDate] The new event end date
* @return Returns a Promise
*/
@Cordova({
platforms: ['iOS']
})
modifyEvent(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date,
newTitle?: string,
newLocation?: string,
newNotes?: string,
newStartDate?: Date,
newEndDate?: Date
): Promise<any> { return; }
/**
* Modify an event with additional options. (iOS only)
*
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @param {string} [newTitle] The new event title
* @param {string} [newLocation] The new event location
* @param {string} [newNotes] The new event notes
* @param {Date} [newStartDate] The new event start date
* @param {Date} [newEndDate] The new event end date
* @param {CalendarOptions} [filterOptions] Event Options, see `getCalendarOptions`
* @param {CalendarOptions} [newOptions] New event options, see `getCalendarOptions`
* @return Returns a Promise
*/
@Cordova({
platforms: ['iOS']
})
modifyEventWithOptions(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date,
newTitle?: string,
newLocation?: string,
newNotes?: string,
newStartDate?: Date,
newEndDate?: Date,
filterOptions?: CalendarOptions,
newOptions?: CalendarOptions
): Promise<any> { return; }
/**
* Delete an event.
*
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @return Returns a Promise
*/
@Cordova()
deleteEvent(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date
): Promise<any> { return; }
/**
* Delete an event from the specified Calendar. (iOS only)
*
* @param {string} [title] The event title
* @param {string} [location] The event location
* @param {string} [notes] The event notes
* @param {Date} [startDate] The event start date
* @param {Date} [endDate] The event end date
* @param {string} calendarName
* @return Returns a Promise
*/
@Cordova({
platforms: ['iOS']
})
deleteEventFromNamedCalendar(
title?: string,
location?: string,
notes?: string,
startDate?: Date,
endDate?: Date,
calendarName?: string
): Promise<any> { return; }
/**
* Open the calendar at the specified date.
* @param {Date} date The date you want to open the calendar on
* @return {Promise<any>} Promise returns a promise
*/
@Cordova()
openCalendar(date: Date): Promise<any> { return; }
}
src/@ionic-native/plugins/call-number/index.ts
+46
View File
@@ -0,0 +1,46 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Call Number
* @description
* Call a number directly from your Cordova/Ionic application.
*
* @usage
* ```
* import {CallNumber} from '@ionic-native/call-number';
*
* constructor(private callNumber: CallNumber) { }
*
* ...
*
*
* this.callNumber.callNumber(18001010101, true)
* .then(() => console.log('Launched dialer!'))
* .catch(() => console.log('Error launching dialer'));
*
* ```
*/
@Plugin({
pluginName: 'CallNumber',
plugin: 'call-number',
pluginRef: 'plugins.CallNumber',
repo: 'https://github.com/Rohfosho/CordovaCallNumberPlugin',
platforms: ['iOS', 'Android']
})
@Injectable()
export class CallNumber {
/**
* Calls a phone number
* @param numberToCall {string} The phone number to call as a string
* @param bypassAppChooser {boolean} Set to true to bypass the app chooser and go directly to dialer
* @return {Promise<any>}
*/
@Cordova({
callbackOrder: 'reverse'
})
callNumber(numberToCall: string, bypassAppChooser: boolean): Promise<any> {
return;
}
}
src/@ionic-native/plugins/camera-preview/index.ts
+247
View File
@@ -0,0 +1,247 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface CameraPreviewDimensions {
/** The width of the camera preview, default to window.screen.width */
width?: number;
/** The height of the camera preview, default to window.screen.height */
height?: number;
}
export interface CameraPreviewOptions {
/** The left edge in pixels, default 0 */
x?: number;
/** The top edge in pixels, default 0 */
y?: number;
/** The width in pixels, default window.screen.width */
width?: number;
/** The height in pixels, default window.screen.height */
height?: number;
/** Choose the camera to use 'front' or 'rear', default 'front' */
camera?: string;
/** Tap to take a photo, default true (picture quality by default : 85) */
tapPhoto?: boolean;
/** Preview box drag across the screen, default 'false' */
previewDrag?: boolean;
/** Preview box to the back of the webview (true => back, false => front) , default false */
toBack?: boolean;
/** Alpha channel of the preview box, float, [0,1], default 1 */
alpha?: number;
}
export interface CameraPreviewPictureOptions {
/** The width in pixels, default 0 */
width?: number;
/** The height in pixels, default 0 */
height?: number;
/** The picture quality, 0 - 100, default 85 */
quality?: number;
}
/**
* @beta
* @name Camera Preview
* @description
* Showing camera preview in HTML
*
* Requires Cordova plugin: `https://github.com/cordova-plugin-camera-preview/cordova-plugin-camera-preview.git`. For more info, please see the [Cordova Camera Preview docs](https://github.com/cordova-plugin-camera-preview/cordova-plugin-camera-preview).
*
* @usage
* ```typescript
* import { CameraPreview, PictureOptions, CameraPreviewOptions, CameraPreviewDimensions } from 'ionic-native';
*
* constructor(private cameraPreview: CameraPreview) { }
*
* ...
*
* // camera options (Size and location). In the following example, the preview uses the rear camera and display the preview in the back of the webview
* const cameraPreviewOpts: CameraPreviewOptions = {
* x: 0,
* y: 0,
* width: window.screen.width,
* height: window.screen.height,
* camera: 'rear',
* tapPhoto: true,
* previewDrag: true,
* toBack: true,
* alpha: 1
* };
*
* // start camera
* this.cameraPreview.startCamera(cameraPreviewOpts).then(
* (res) => {
* console.log(res)
* },
* (err) => {
* console.log(err)
* });
*
* // Set the handler to run every time we take a picture
* this.cameraPreview.setOnPictureTakenHandler().subscribe((result) => {
* console.log(result);
* // do something with the result
* });
*
*
* // picture options
* const pictureOpts: PictureOptions = {
* width: 1280,
* height: 1280,
* quality: 85
* }
*
* // take a picture
* this.cameraPreview.takePicture(this.pictureOpts).then((imageData) => {
* this.picture = 'data:image/jpeg;base64,' + imageData;
* }, (err) => {
* console.log(err);
* this.picture = 'assets/img/test.jpg';
* });
*
*
* // Switch camera
* this.cameraPreview.switchCamera();
*
* // set color effect to negative
* this.cameraPreview.setColorEffect('negative');
*
* // Stop the camera preview
* this.cameraPreview.stopCamera();
*
* ```
*
* @interfaces
* CameraPreviewOptions
* CameraPreviewPictureOptions
* CameraPreviewDimensions
*/
@Plugin({
pluginName: 'CameraPreview',
plugin: 'cordova-plugin-camera-preview',
pluginRef: 'CameraPreview',
repo: 'https://github.com/cordova-plugin-camera-preview/cordova-plugin-camera-preview',
platforms: ['Android', 'iOS']
})
@Injectable()
export class CameraPreview {
/**
* Starts the camera preview instance.
* @param {CameraPreviewOptions} options
* @return {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
startCamera(options: CameraPreviewOptions): Promise<any> { return; }
/**
* Stops the camera preview instance. (iOS & Android)
* @return {Promise<any>}
*/
@Cordova({
successIndex: 0,
errorIndex: 1
})
stopCamera(): Promise<any> { return; }
/**
* Switch from the rear camera and front camera, if available.
* @return {Promise<any>}
*/
@Cordova({
successIndex: 0,
errorIndex: 1
})
switchCamera(): Promise<any> { return; }
/**
* Hide the camera preview box.
* @return {Promise<any>}
*/
@Cordova({
successIndex: 0,
errorIndex: 1
})
hide(): Promise<any> { return; }
/**
* Show the camera preview box.
* @return {Promise<any>}
*/
@Cordova({
successIndex: 0,
errorIndex: 1
})
show(): Promise<any> { return; }
/**
* Take the picture (base64)
* @param options {CameraPreviewPictureOptions} optional - size and quality of the picture to take
* @return {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
takePicture(options?: CameraPreviewPictureOptions): Promise<any> { return; }
/**
*
* Set camera color effect.
* @static
* @param {string} effect name : 'none' (iOS & Android), 'aqua' (Android), 'blackboard' (Android), 'mono' (iOS & Android), 'negative' (iOS & Android), 'posterize' (iOS & Android), 'sepia' (iOS & Android), 'solarize' (Android) or 'whiteboard' (Android)
* @return {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
setColorEffect(effect: string): Promise<any> { return; }
/**
* Set the zoom (Android)
* @param zoom {number} Zoom value
* @return {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
setZoom(zoom?: number): Promise<any> { return; }
/**
* Set the preview Size
* @param dimensions {CameraPreviewDimensions}
* @return {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2,
platforms: ['Android']
})
setPreviewSize(dimensions?: CameraPreviewDimensions): Promise<any> { return; }
/**
* Set the flashmode
* @param flashMode {string} 'off' (iOS & Android), 'on' (iOS & Android), 'auto' (iOS & Android), 'torch' (Android)
* @return {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
setFlashMode(flashMode?: string): Promise<any> { return; }
}
src/@ionic-native/plugins/camera/index.ts
+222
View File
@@ -0,0 +1,222 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface CameraOptions {
/** Picture quality in range 0-100. Default is 50 */
quality?: number;
/**
* Choose the format of the return value.
* Defined in Camera.DestinationType. Default is FILE_URI.
* DATA_URL : 0, Return image as base64-encoded string,
* FILE_URI : 1, Return image file URI,
* NATIVE_URI : 2 Return image native URI
* (e.g., assets-library:// on iOS or content:// on Android)
*/
destinationType?: number;
/**
* Set the source of the picture.
* Defined in Camera.PictureSourceType. Default is CAMERA.
* PHOTOLIBRARY : 0,
* CAMERA : 1,
* SAVEDPHOTOALBUM : 2
*/
sourceType?: number;
/** Allow simple editing of image before selection. */
allowEdit?: boolean;
/**
* Choose the returned image file's encoding.
* Defined in Camera.EncodingType. Default is JPEG
* JPEG : 0 Return JPEG encoded image
* PNG : 1 Return PNG encoded image
*/
encodingType?: number;
/**
* Width in pixels to scale image. Must be used with targetHeight.
* Aspect ratio remains constant.
*/
targetWidth?: number;
/**
* Height in pixels to scale image. Must be used with targetWidth.
* Aspect ratio remains constant.
*/
targetHeight?: number;
/**
* Set the type of media to select from. Only works when PictureSourceType
* is PHOTOLIBRARY or SAVEDPHOTOALBUM. Defined in Camera.MediaType
* PICTURE: 0 allow selection of still pictures only. DEFAULT.
* Will return format specified via DestinationType
* VIDEO: 1 allow selection of video only, WILL ALWAYS RETURN FILE_URI
* ALLMEDIA : 2 allow selection from all media types
*/
mediaType?: number;
/** Rotate the image to correct for the orientation of the device during capture. */
correctOrientation?: boolean;
/** Save the image to the photo album on the device after capture. */
saveToPhotoAlbum?: boolean;
/**
* Choose the camera to use (front- or back-facing).
* Defined in Camera.Direction. Default is BACK.
* BACK: 0
* FRONT: 1
*/
cameraDirection?: number;
/** iOS-only options that specify popover location in iPad. Defined in CameraPopoverOptions. */
popoverOptions?: CameraPopoverOptions;
}
/**
* iOS-only parameters that specify the anchor element location and arrow direction
* of the popover when selecting images from an iPad's library or album.
*/
export interface CameraPopoverOptions {
x: number;
y: number;
width: number;
height: number;
/**
* Direction the arrow on the popover should point. Defined in Camera.PopoverArrowDirection
* Matches iOS UIPopoverArrowDirection constants.
* ARROW_UP : 1,
* ARROW_DOWN : 2,
* ARROW_LEFT : 4,
* ARROW_RIGHT : 8,
* ARROW_ANY : 15
*/
arrowDir: number;
}
/**
* @name Camera
* @description
* Take a photo or capture video.
*
* Requires {@link module:driftyco/ionic-native} and the Cordova plugin: `cordova-plugin-camera`. For more info, please see the [Cordova Camera Plugin Docs](https://github.com/apache/cordova-plugin-camera).
*
* @usage
* ```typescript
* import { Camera, CameraOptions } from '@ionic-native/camera';
*
* constructor(private camera: Camera) { }
*
* ...
*
*
* constant options: CameraOptions = {
* quality: 100,
* destinationType: this.camera.DestinationType.DATA_URL,
* enodingType: this.camera.EncodingType.JPEG,
* mediaType: this.camera.MediaType.PICTURE
* }
*
* this.camera.getPicture(options).then((imageData) => {
* // imageData is either a base64 encoded string or a file URI
* // If it's base64:
* let base64Image = 'data:image/jpeg;base64,' + imageData;
* }, (err) => {
* // Handle error
* });
* ```
* @interfaces
* CameraOptions
* CameraPopoverOptions
*/
@Injectable()
@Plugin({
pluginName: 'Camera',
plugin: 'cordova-plugin-camera',
pluginRef: 'navigator.camera',
repo: 'https://github.com/apache/cordova-plugin-camera',
platforms: ['Android', 'BlackBerry', 'Browser', 'Firefox', 'FireOS', 'iOS', 'Windows', 'Windows Phone 8', 'Ubuntu']
})
export class Camera {
/**
* Constant for possible destination types
*/
DestinationType = {
/** Return base64 encoded string. DATA_URL can be very memory intensive and cause app crashes or out of memory errors. Use FILE_URI or NATIVE_URI if possible */
DATA_URL: 0,
/** Return file uri (content://media/external/images/media/2 for Android) */
FILE_URI: 1,
/** Return native uri (eg. asset-library://... for iOS) */
NATIVE_URI: 2
};
/**
* Convenience constant
*/
EncodingType = {
/** Return JPEG encoded image */
JPEG: 0,
/** Return PNG encoded image */
PNG: 1
};
/**
* Convenience constant
*/
MediaType = {
/** Allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType */
PICTURE: 0,
/** Allow selection of video only, ONLY RETURNS URL */
VIDEO: 1,
/** Allow selection from all media types */
ALLMEDIA: 2
};
/**
* Convenience constant
*/
PictureSourceType = {
/** Choose image from picture library (same as SAVEDPHOTOALBUM for Android) */
PHOTOLIBRARY: 0,
/** Take picture from camera */
CAMERA: 1,
/** Choose image from picture library (same as PHOTOLIBRARY for Android) */
SAVEDPHOTOALBUM: 2
};
/**
* Convenience constant
*/
PopoverArrowDirection = {
ARROW_UP: 1,
ARROW_DOWN: 2,
ARROW_LEFT: 4,
ARROW_RIGHT: 8,
ARROW_ANY: 15
};
/**
* Convenience constant
*/
Direction = {
/** Use the back-facing camera */
BACK: 0,
/** Use the front-facing camera */
FRONT: 1
};
/**
* Take a picture or video, or load one from the library.
* @param {CameraOptions?} options optional. Options that you want to pass to the camera. Encoding type, quality, etc. Platform-specific quirks are described in the [Cordova plugin docs](https://github.com/apache/cordova-plugin-camera#cameraoptions-errata-).
* @returns {Promise<any>} Returns a Promise that resolves with Base64 encoding of the image data, or the image file URI, depending on cameraOptions, otherwise rejects with an error.
*/
@Cordova({
callbackOrder: 'reverse'
})
getPicture(options?: CameraOptions): Promise<any> { return; }
/**
* Remove intermediate image files that are kept in temporary storage after calling camera.getPicture.
* Applies only when the value of Camera.sourceType equals Camera.PictureSourceType.CAMERA and the Camera.destinationType equals Camera.DestinationType.FILE_URI.
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['iOS']
})
cleanup(): Promise<any> { return; };
}
src/@ionic-native/plugins/card-io/index.ts
+196
View File
@@ -0,0 +1,196 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface CardIOOptions {
/**
* Set to true to require expiry date
*/
requireExpiry?: boolean;
/**
* The user will be prompted for the card CVV
*/
requireCVV?: boolean;
/**
* The user will be prompted for the card billing postal code.
*/
requirePostalCode?: boolean;
/**
* Removes the keyboard button from the scan screen.
*/
supressManual?: boolean;
/**
* The postal code will only collect numeric input. Set this if you know the expected country's postal code has only numeric postal codes.
*/
restrictPostalCodeToNumericOnly?: boolean;
/**
* The theme for the card.io Activity's will be set to the theme of the application.
*/
keepApplicationTheme?: boolean;
/**
* The user will be prompted for the cardholder name
*/
requireCardholderName?: boolean;
/**
* Used to display instructions to the user while they are scanning their card.
*/
scanInstructions?: string;
/**
* If set, the card will not be scanned with the camera.
*/
noCamera?: boolean;
/**
* If scanExpiry is true, an attempt to extract the expiry from the card image will be made.
*/
scanExpiry?: boolean;
/**
* The preferred language for all strings appearing in the user interface. If not set, or if set to null, defaults to the device's current language setting.
*/
languageOrLocale?: string;
/**
* Changes the color of the guide overlay on the camera. The color is provided in hexadecimal format (e.g. `#FFFFFF`)
*/
guideColor?: string;
/**
* The user will not be prompted to confirm their card number after processing.
*/
supressConfirmation?: boolean;
/**
* The card.io logo will not be shown overlaid on the camera.
*/
hideCardIOLogo?: boolean;
/**
* The card.io logo will be shown instead of the PayPal logo.
*/
useCardIOLogo?: boolean;
/**
* Once a card image has been captured but before it has been processed, this value will determine whether to continue processing as usual.
*/
supressScan?: boolean;
}
export interface CardIOResponse {
/**
* Card type
*/
cardType: string;
/**
* Masked card number, showing only last 4 digits
*/
redactedCardNumber: string;
/**
* Full card number
*/
cardNumber: string;
/**
* Expiry month
*/
expiryMonth: number;
/**
* Expiry year
*/
expiryYear: number;
/**
* CVV
*/
cvv: string;
/**
* Postal code
*/
postalCode: string;
/**
* Cardholder name
*/
cardholderName: string;
}
/**
* @name Card IO
* @description
* @usage
* ```
* import { CardIO } from '@ionic-native/card-io';
*
* constructor(private cardIO: CardIO) { }
*
* ...
*
*
* this.cardIO.canScan()
* .then(
* (res: boolean) => {
* if(res){
* let options = {
* requireExpiry: true,
* requireCCV: false,
* requirePostalCode: false
* };
* CardIO.scan(options);
* }
* }
* );
* ```
* @interfaces
* CardIOOptions
* CardIOResponse
*/
@Plugin({
pluginName: 'CardIO',
plugin: 'card.io.cordova.mobilesdk',
pluginRef: 'CardIO',
repo: 'https://github.com/card-io/card.io-Cordova-Plugin',
platforms: ['iOS', 'Android']
})
@Injectable()
export class CardIO {
/**
* Check whether card scanning is currently available. (May vary by
* device, OS version, network connectivity, etc.)
*
* @returns {Promise<boolean>}
*/
@Cordova()
canScan(): Promise<boolean> { return; }
/**
* Scan a credit card with card.io.
* @param {CardIOOptions} options Options for configuring the plugin
* @returns {Promise<any>}
*/
@Cordova()
scan(options?: CardIOOptions): Promise<CardIOResponse> { return; }
/**
* Retrieve the version of the card.io library. Useful when contacting support.
* @returns {Promise<string>}
*/
@Cordova()
version(): Promise<string> { return; }
}
src/@ionic-native/plugins/clipboard/index.ts
+57
View File
@@ -0,0 +1,57 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Clipboard
* @description
* Clipboard management plugin for Cordova that supports iOS, Android, and Windows Phone 8.
*
* Requires Cordova plugin: https://github.com/VersoSolutions/CordovaClipboard
* For more info, please see the [Clipboard plugin docs](https://github.com/VersoSolutions/CordovaClipboard.git).
*
* @usage
* ```typescript
* import { Clipboard } from '@ionic-native/clipboard';
*
* constructor(private clipboard: Clipboard) { }
*
* ...
*
*
* this.clipboard.copy('Hello world');
*
* this.clipboard.paste().then(
* (resolve: string) => {
* alert(resolve);
* },
* (reject: string) => {
* alert('Error: ' + reject);
* }
* );
* ```
*/
@Plugin({
pluginName: 'Clipboard',
plugin: 'https://github.com/VersoSolutions/CordovaClipboard.git',
pluginRef: 'cordova.plugins.clipboard',
repo: 'https://github.com/VersoSolutions/CordovaClipboard',
platforms: ['Amazon Fire OS', 'iOS', 'Android', 'BlackBerry 10', 'Windows Phone 7', 'Windows Phone 8', 'Windows', 'Firefox OS', 'Browser']
})
@Injectable()
export class Clipboard {
/**
* Copies the given text
* @param {string} text Text that gets copied on the system clipboard
* @returns {Promise<any>} Returns a promise after the text has been copied
*/
@Cordova()
copy(text: string): Promise<any> { return; }
/**
* Pastes the text stored in clipboard
* @returns {Promise<any>} Returns a promise after the text has been pasted
*/
@Cordova()
paste(): Promise<any> { return; }
}
src/@ionic-native/plugins/code-push/index.ts
+525
View File
@@ -0,0 +1,525 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
namespace Http {
export const enum Verb {
GET, HEAD, POST, PUT, DELETE, TRACE, OPTIONS, CONNECT, PATCH
}
export interface Response {
statusCode: number;
body?: string;
}
export interface Requester {
request(verb: Verb, url: string, callback: Callback<Response>): void;
request(verb: Verb, url: string, requestBody: string, callback: Callback<Response>): void;
}
}
/**
* Defines a package. All fields are non-nullable, except when retrieving the currently running package on the first run of the app,
* in which case only the appVersion is compulsory.
*
* !! THIS TYPE IS READ FROM NATIVE CODE AS WELL. ANY CHANGES TO THIS INTERFACE NEEDS TO BE UPDATED IN NATIVE CODE !!
*/
export interface IPackage {
deploymentKey: string;
description: string;
label: string;
appVersion: string;
isMandatory: boolean;
packageHash: string;
packageSize: number;
failedInstall: boolean;
}
/**
* Defines a remote package, which represents an update package available for download.
*/
export interface IRemotePackage extends IPackage {
/**
* The URL at which the package is available for download.
*/
downloadUrl: string;
/**
* Downloads the package update from the CodePush service.
*
* @param downloadSuccess Called with one parameter, the downloaded package information, once the download completed successfully.
* @param downloadError Optional callback invoked in case of an error.
* @param downloadProgress Optional callback invoked during the download process. It is called several times with one DownloadProgress parameter.
*/
download(downloadSuccess: SuccessCallback<ILocalPackage>, downloadError?: ErrorCallback, downloadProgress?: SuccessCallback<DownloadProgress>): void;
/**
* Aborts the current download session, previously started with download().
*
* @param abortSuccess Optional callback invoked if the abort operation succeeded.
* @param abortError Optional callback invoked in case of an error.
*/
abortDownload(abortSuccess?: SuccessCallback<void>, abortError?: ErrorCallback): void;
}
/**
* Defines a local package.
*
* !! THIS TYPE IS READ FROM NATIVE CODE AS WELL. ANY CHANGES TO THIS INTERFACE NEEDS TO BE UPDATED IN NATIVE CODE !!
*/
export interface ILocalPackage extends IPackage {
/**
* The local storage path where this package is located.
*/
localPath: string;
/**
* Indicates if the current application run is the first one after the package was applied.
*/
isFirstRun: boolean;
/**
* Applies this package to the application. The application will be reloaded with this package and on every application launch this package will be loaded.
* On the first run after the update, the application will wait for a codePush.notifyApplicationReady() call. Once this call is made, the install operation is considered a success.
* Otherwise, the install operation will be marked as failed, and the application is reverted to its previous version on the next run.
*
* @param installSuccess Callback invoked if the install operation succeeded.
* @param installError Optional callback inovoked in case of an error.
* @param installOptions Optional parameter used for customizing the installation behavior.
*/
install(installSuccess: SuccessCallback<InstallMode>, errorCallback?: ErrorCallback, installOptions?: InstallOptions): void;
}
/**
* Decomposed static side of RemotePackage.
* For Class Decomposition guidelines see http://www.typescriptlang.org/Handbook#writing-dts-files-guidelines-and-specifics
*/
/* tslint:disable */
interface RemotePackage_Static {
new (): IRemotePackage;
}
/* tslint:enable */
/**
* Decomposed static side of LocalPackage.
* For Class Decomposition guidelines see http://www.typescriptlang.org/Handbook#writing-dts-files-guidelines-and-specifics
*/
/* tslint:disable */
interface LocalPackage_Static {
new (): ILocalPackage;
}
/* tslint:enable */
declare var RemotePackage: RemotePackage_Static;
declare var LocalPackage: LocalPackage_Static;
/**
* Defines the JSON format of the current package information file.
* This file is stored in the local storage of the device and persists between store updates and code-push updates.
*
* !! THIS FILE IS READ FROM NATIVE CODE AS WELL. ANY CHANGES TO THIS INTERFACE NEEDS TO BE UPDATED IN NATIVE CODE !!
*/
interface IPackageInfoMetadata extends ILocalPackage {
nativeBuildTime: string;
}
interface NativeUpdateNotification {
updateAppVersion: boolean; // Always true
appVersion: string;
}
export interface Callback<T> { (error: Error, parameter: T): void; }
export interface SuccessCallback<T> { (result?: T): void; }
export interface ErrorCallback { (error?: Error): void; }
interface Configuration {
appVersion: string;
clientUniqueId: string;
deploymentKey: string;
serverUrl: string;
ignoreAppVersion?: boolean;
}
declare class AcquisitionStatus {
static DeploymentSucceeded: string;
static DeploymentFailed: string;
}
declare class AcquisitionManager {
constructor(httpRequester: Http.Requester, configuration: Configuration);
public queryUpdateWithCurrentPackage(currentPackage: IPackage, callback?: Callback<IRemotePackage | NativeUpdateNotification>): void;
public reportStatusDeploy(pkg?: IPackage, status?: string, previousLabelOrAppVersion?: string, previousDeploymentKey?: string, callback?: Callback<void>): void;
public reportStatusDownload(pkg: IPackage, callback?: Callback<void>): void;
}
interface CodePushCordovaPlugin {
/**
* Get the current package information.
*
* @param packageSuccess Callback invoked with the currently deployed package information.
* @param packageError Optional callback invoked in case of an error.
*/
getCurrentPackage(packageSuccess: SuccessCallback<ILocalPackage>, packageError?: ErrorCallback): void;
/**
* Gets the pending package information, if any. A pending package is one that has been installed but the application still runs the old code.
* This happends only after a package has been installed using ON_NEXT_RESTART or ON_NEXT_RESUME mode, but the application was not restarted/resumed yet.
*/
getPendingPackage(packageSuccess: SuccessCallback<ILocalPackage>, packageError?: ErrorCallback): void;
/**
* Checks with the CodePush server if an update package is available for download.
*
* @param querySuccess Callback invoked in case of a successful response from the server.
* The callback takes one RemotePackage parameter. A non-null package is a valid update.
* A null package means the application is up to date for the current native application version.
* @param queryError Optional callback invoked in case of an error.
* @param deploymentKey Optional deployment key that overrides the config.xml setting.
*/
checkForUpdate(querySuccess: SuccessCallback<IRemotePackage>, queryError?: ErrorCallback, deploymentKey?: string): void;
/**
* Notifies the plugin that the update operation succeeded and that the application is ready.
* Calling this function is required on the first run after an update. On every subsequent application run, calling this function is a noop.
* If using sync API, calling this function is not required since sync calls it internally.
*
* @param notifySucceeded Optional callback invoked if the plugin was successfully notified.
* @param notifyFailed Optional callback invoked in case of an error during notifying the plugin.
*/
notifyApplicationReady(notifySucceeded?: SuccessCallback<void>, notifyFailed?: ErrorCallback): void;
/**
* Reloads the application. If there is a pending update package installed using ON_NEXT_RESTART or ON_NEXT_RESUME modes, the update
* will be immediately visible to the user. Otherwise, calling this function will simply reload the current version of the application.
*/
restartApplication(installSuccess: SuccessCallback<void>, errorCallback?: ErrorCallback): void;
/**
* Convenience method for installing updates in one method call.
* This method is provided for simplicity, and its behavior can be replicated by using window.codePush.checkForUpdate(), RemotePackage's download() and LocalPackage's install() methods.
*
* The algorithm of this method is the following:
* - Checks for an update on the CodePush server.
* - If an update is available
* - If the update is mandatory and the alertMessage is set in options, the user will be informed that the application will be updated to the latest version.
* The update package will then be downloaded and applied.
* - If the update is not mandatory and the confirmMessage is set in options, the user will be asked if they want to update to the latest version.
* If they decline, the syncCallback will be invoked with SyncStatus.UPDATE_IGNORED.
* - Otherwise, the update package will be downloaded and applied with no user interaction.
* - If no update is available on the server, or if a previously rolled back update is available and the ignoreFailedUpdates is set to true, the syncCallback will be invoked with the SyncStatus.UP_TO_DATE.
* - If an error occurs during checking for update, downloading or installing it, the syncCallback will be invoked with the SyncStatus.ERROR.
*
* @param syncCallback Optional callback to be called with the status of the sync operation.
* The callback will be called only once, and the possible statuses are defined by the SyncStatus enum.
* @param syncOptions Optional SyncOptions parameter configuring the behavior of the sync operation.
* @param downloadProgress Optional callback invoked during the download process. It is called several times with one DownloadProgress parameter.
*
*/
sync(syncCallback?: SuccessCallback<SyncStatus>, syncOptions?: SyncOptions, downloadProgress?: SuccessCallback<DownloadProgress>): void;
}
/**
* Defines the possible result statuses of the window.codePush.sync operation.
*/
export enum SyncStatus {
/**
* The application is up to date.
*/
UP_TO_DATE,
/**
* An update is available, it has been downloaded, unzipped and copied to the deployment folder.
* After the completion of the callback invoked with SyncStatus.UPDATE_INSTALLED, the application will be reloaded with the updated code and resources.
*/
UPDATE_INSTALLED,
/**
* An optional update is available, but the user declined to install it. The update was not downloaded.
*/
UPDATE_IGNORED,
/**
* An error happened during the sync operation. This might be an error while communicating with the server, downloading or unziping the update.
* The console logs should contain more information about what happened. No update has been applied in this case.
*/
ERROR,
/**
* There is an ongoing sync in progress, so this attempt to sync has been aborted.
*/
IN_PROGRESS,
/**
* Intermediate status - the plugin is about to check for updates.
*/
CHECKING_FOR_UPDATE,
/**
* Intermediate status - a user dialog is about to be displayed. This status will be reported only if user interaction is enabled.
*/
AWAITING_USER_ACTION,
/**
* Intermediate status - the update package is about to be downloaded.
*/
DOWNLOADING_PACKAGE,
/**
* Intermediate status - the update package is about to be installed.
*/
INSTALLING_UPDATE
}
/**
* Defines the available install modes for updates.
*/
export enum InstallMode {
/**
* The update will be applied to the running application immediately. The application will be reloaded with the new content immediately.
*/
IMMEDIATE,
/**
* The update is downloaded but not installed immediately. The new content will be available the next time the application is started.
*/
ON_NEXT_RESTART,
/**
* The udpate is downloaded but not installed immediately. The new content will be available the next time the application is resumed or restarted, whichever event happends first.
*/
ON_NEXT_RESUME
}
/**
* Defines the install operation options.
*/
export interface InstallOptions {
/**
* Used to specify the InstallMode used for the install operation. This is optional and defaults to InstallMode.ON_NEXT_RESTART.
*/
installMode?: InstallMode;
/**
* If installMode === ON_NEXT_RESUME, the minimum amount of time (in seconds) which needs to pass with the app in the background before an update install occurs when the app is resumed.
*/
minimumBackgroundDuration?: number;
/**
* Used to specify the InstallMode used for the install operation if the update is mandatory. This is optional and defaults to InstallMode.IMMEDIATE.
*/
mandatoryInstallMode?: InstallMode;
}
/**
* Defines the sync operation options.
*/
export interface SyncOptions extends InstallOptions {
/**
* Optional boolean flag. If set, previous updates which were rolled back will be ignored. Defaults to true.
*/
ignoreFailedUpdates?: boolean;
/**
* Used to enable, disable or customize the user interaction during sync.
* If set to false, user interaction will be disabled. If set to true, the user will be alerted or asked to confirm new updates, based on whether the update is mandatory.
* To customize the user dialog, this option can be set to a custom UpdateDialogOptions instance.
*/
updateDialog?: boolean | UpdateDialogOptions;
/**
* Overrides the config.xml deployment key when checking for updates.
*/
deploymentKey?: string;
}
/**
* Defines the configuration options for the alert or confirmation dialog
*/
export interface UpdateDialogOptions {
/**
* If a mandatory update is available and this option is set, the message will be displayed to the user in an alert dialog before downloading and installing the update.
* The user will not be able to cancel the operation, since the update is mandatory.
*/
mandatoryUpdateMessage?: string;
/**
* If an optional update is available and this option is set, the message will be displayed to the user in a confirmation dialog.
* If the user confirms the update, it will be downloaded and installed. Otherwise, the update update is not downloaded.
*/
optionalUpdateMessage?: string;
/**
* The title of the dialog box used for interacting with the user in case of a mandatory or optional update.
* This title will only be used if at least one of mandatoryUpdateMessage or optionalUpdateMessage options are set.
*/
updateTitle?: string;
/**
* The label of the confirmation button in case of an optional update.
*/
optionalInstallButtonLabel?: string;
/**
* The label of the cancel button in case of an optional update.
*/
optionalIgnoreButtonLabel?: string;
/**
* The label of the continue button in case of a mandatory update.
*/
mandatoryContinueButtonLabel?: string;
/**
* Flag indicating if the update description provided by the CodePush server should be displayed in the dialog box appended to the update message.
*/
appendReleaseDescription?: boolean;
/**
* Optional prefix to add to the release description.
*/
descriptionPrefix?: string;
}
/**
* Defines the JSON format of the package diff manifest file.
*/
interface IDiffManifest {
deletedFiles: string[];
}
/**
* Defines the format of the DownloadProgress object, used to send periodical update notifications on the progress of the update download.
*/
export interface DownloadProgress {
totalBytes: number;
receivedBytes: number;
}
/**
* @name Code Push
* @description
* CodePush plugin for Cordova by Microsoft that supports iOS and Android.
*
* For more info, please see https://github.com/ksachdeva/ionic2-code-push-example
*
* @usage
* ```typescript
* import { CodePush } from '@ionic-native/code-push';
*
* constructor(private codePush: CodePush) { }
*
* ...
*
* // note - mostly error & completed methods of observable will not fire
* // as syncStatus will contain the current state of the update
* this.codePush.sync().subscribe((syncStatus) => console.log(syncStatus));
*
* const downloadProgress = (progress) => { console.log(`Downloaded ${progress.receivedBytes} of ${progress.totalBytes}`); }
* this.codePush.sync({}, downloadProgress).subscribe((syncStatus) => console.log(syncStatus));
*
* ```
*/
@Plugin({
pluginName: 'CodePush',
plugin: 'cordova-plugin-code-push',
pluginRef: 'codePush',
repo: 'https://github.com/Microsoft/cordova-plugin-code-push',
platforms: ['Android', 'iOS']
})
@Injectable()
export class CodePush {
/**
* Get the current package information.
*
* @param packageSuccess Callback invoked with the currently deployed package information.
* @param packageError Optional callback invoked in case of an error.
* @returns {Promise<ILocalPackage>}
*/
@Cordova()
getCurrentPackage(): Promise<ILocalPackage> {
return;
}
/**
* Gets the pending package information, if any. A pending package is one that has been installed but the application still runs the old code.
* This happends only after a package has been installed using ON_NEXT_RESTART or ON_NEXT_RESUME mode, but the application was not restarted/resumed yet.
* @returns {Promise<ILocalPackage>}
*/
@Cordova()
getPendingPackage(): Promise<ILocalPackage> {
return;
}
/**
* Checks with the CodePush server if an update package is available for download.
*
* @param querySuccess Callback invoked in case of a successful response from the server.
* The callback takes one RemotePackage parameter. A non-null package is a valid update.
* A null package means the application is up to date for the current native application version.
* @param queryError Optional callback invoked in case of an error.
* @param deploymentKey Optional deployment key that overrides the config.xml setting.
* @returns {Promise<IRemotePackage>}
*/
@Cordova({
callbackOrder: 'reverse'
})
checkForUpdate(deploymentKey?: string): Promise<IRemotePackage> {
return;
}
/**
* Notifies the plugin that the update operation succeeded and that the application is ready.
* Calling this function is required on the first run after an update. On every subsequent application run, calling this function is a noop.
* If using sync API, calling this function is not required since sync calls it internally.
*
* @param notifySucceeded Optional callback invoked if the plugin was successfully notified.
* @param notifyFailed Optional callback invoked in case of an error during notifying the plugin.
* @returns {Promise<void>}
*/
@Cordova()
notifyApplicationReady(): Promise<void> {
return;
}
/**
* Reloads the application. If there is a pending update package installed using ON_NEXT_RESTART or ON_NEXT_RESUME modes, the update
* will be immediately visible to the user. Otherwise, calling this function will simply reload the current version of the application.
* @returns {Promise<void>}
*/
@Cordova()
restartApplication(): Promise<void> {
return;
}
/**
* Convenience method for installing updates in one method call.
* This method is provided for simplicity, and its behavior can be replicated by using window.codePush.checkForUpdate(), RemotePackage's download() and LocalPackage's install() methods.
*
* The algorithm of this method is the following:
* - Checks for an update on the CodePush server.
* - If an update is available
* - If the update is mandatory and the alertMessage is set in options, the user will be informed that the application will be updated to the latest version.
* The update package will then be downloaded and applied.
* - If the update is not mandatory and the confirmMessage is set in options, the user will be asked if they want to update to the latest version.
* If they decline, the syncCallback will be invoked with SyncStatus.UPDATE_IGNORED.
* - Otherwise, the update package will be downloaded and applied with no user interaction.
* - If no update is available on the server, or if a previously rolled back update is available and the ignoreFailedUpdates is set to true, the syncCallback will be invoked with the SyncStatus.UP_TO_DATE.
* - If an error occurs during checking for update, downloading or installing it, the syncCallback will be invoked with the SyncStatus.ERROR.
*
* @param syncCallback Optional callback to be called with the status of the sync operation.
* @param syncOptions Optional SyncOptions parameter configuring the behavior of the sync operation.
* @param downloadProgress Optional callback invoked during the download process. It is called several times with one DownloadProgress parameter.
* @returns {Observable<SyncStatus>}
*
*/
@Cordova({
observable: true,
successIndex: 0,
errorIndex: 3 // we don't need this, so we set it to a value higher than # of args
})
sync(syncOptions?: SyncOptions, downloadProgress?: SuccessCallback<DownloadProgress>): Observable<SyncStatus> {
return;
}
}
src/@ionic-native/plugins/contacts/index.ts
+338
View File
@@ -0,0 +1,338 @@
import { Injectable } from '@angular/core';
import { CordovaInstance, InstanceProperty, Plugin, getPromise } from '@ionic-native/core';
declare var window: any,
navigator: any;
export type ContactFieldType = '*' | 'addresses' | 'birthday' | 'categories' | 'country' | 'department' | 'displayName' | 'emails' | 'familyName' | 'formatted' | 'givenName' | 'honorificPrefix' | 'honorificSuffix' | 'id' | 'ims' | 'locality' | 'middleName' | 'name' | 'nickname' | 'note' | 'organizations' | 'phoneNumbers' | 'photos' | 'postalCode' | 'region' | 'streetAddress' | 'title' | 'urls';
export interface IContactProperties {
/** A globally unique identifier. */
id?: string;
/** The name of this Contact, suitable for display to end users. */
displayName?: string;
/** An object containing all components of a persons name. */
name?: IContactName;
/** A casual name by which to address the contact. */
nickname?: string;
/** An array of all the contact's phone numbers. */
phoneNumbers?: IContactField[];
/** An array of all the contact's email addresses. */
emails?: IContactField[];
/** An array of all the contact's addresses. */
addresses?: IContactAddress[];
/** An array of all the contact's IM addresses. */
ims?: IContactField[];
/** An array of all the contact's organizations. */
organizations?: IContactOrganization[];
/** The birthday of the contact. */
birthday?: Date;
/** A note about the contact. */
note?: string;
/** An array of the contact's photos. */
photos?: IContactField[];
/** An array of all the user-defined categories associated with the contact. */
categories?: IContactField[];
/** An array of web pages associated with the contact. */
urls?: IContactField[];
}
/**
* @hidden
*/
export class Contact implements IContactProperties {
private _objectInstance: any;
@InstanceProperty id: string;
@InstanceProperty displayName: string;
@InstanceProperty name: IContactName;
@InstanceProperty nickname: string;
@InstanceProperty phoneNumbers: IContactField[];
@InstanceProperty emails: IContactField[];
@InstanceProperty addresses: IContactAddress[];
@InstanceProperty ims: IContactField[];
@InstanceProperty organizations: IContactOrganization[];
@InstanceProperty birthday: Date;
@InstanceProperty note: string;
@InstanceProperty photos: IContactField[];
@InstanceProperty categories: IContactField[];
@InstanceProperty urls: IContactField[];
constructor() {
this._objectInstance = navigator.contacts.create();
}
clone(): Contact {
let newContact = new Contact();
for (let prop in this) {
if (prop === 'id') return;
newContact[prop] = this[prop];
}
return newContact;
}
@CordovaInstance()
remove(): Promise<any> { return; }
save(): Promise<any> {
return getPromise((resolve, reject) => {
this._objectInstance.save((contact) => {
this._objectInstance = contact;
resolve(this);
}, reject);
});
}
}
/**
* @hidden
*/
export interface IContactError {
/** Error code */
code: number;
/** Error message */
message: string;
}
/**
* @hidden
*/
export declare var ContactError: {
new (code: number): IContactError;
UNKNOWN_ERROR: number;
INVALID_ARGUMENT_ERROR: number;
TIMEOUT_ERROR: number;
PENDING_OPERATION_ERROR: number;
IO_ERROR: number;
NOT_SUPPORTED_ERROR: number;
PERMISSION_DENIED_ERROR: number
};
export interface IContactName {
/** The complete name of the contact. */
formatted?: string;
/** The contact's family name. */
familyName?: string;
/** The contact's given name. */
givenName?: string;
/** The contact's middle name. */
middleName?: string;
/** The contact's prefix (example Mr. or Dr.) */
honorificPrefix?: string;
/** The contact's suffix (example Esq.). */
honorificSuffix?: string;
}
/**
* @hidden
*/
export class ContactName implements IContactName {
constructor(public formatted?: string,
public familyName?: string,
public givenName?: string,
public middleName?: string,
public honorificPrefix?: string,
public honorificSuffix?: string) {}
}
export interface IContactField {
/** A string that indicates what type of field this is, home for example. */
type?: string;
/** The value of the field, such as a phone number or email address. */
value?: string;
/** Set to true if this ContactField contains the user's preferred value. */
pref?: boolean;
}
/**
* @hidden
*/
export class ContactField implements IContactField {
constructor(public type?: string,
public value?: string,
public pref?: boolean) {}
}
export interface IContactAddress {
/** Set to true if this ContactAddress contains the user's preferred value. */
pref?: boolean;
/** A string indicating what type of field this is, home for example. */
type?: string;
/** The full address formatted for display. */
formatted?: string;
/** The full street address. */
streetAddress?: string;
/** The city or locality. */
locality?: string;
/** The state or region. */
region?: string;
/** The zip code or postal code. */
postalCode?: string;
/** The country name. */
country?: string;
}
/**
* @hidden
*/
export class ContactAddress implements IContactAddress {
constructor(public pref?: boolean,
public type?: string,
public formatted?: string,
public streetAddress?: string,
public locality?: string,
public region?: string,
public postalCode?: string,
public country?: string) {}
}
export interface IContactOrganization {
/** Set to true if this ContactOrganization contains the user's preferred value. */
pref?: boolean;
/** A string that indicates what type of field this is, home for example. */
type?: string;
/** The name of the organization. */
name?: string;
/** The department the contract works for. */
department?: string;
/** The contact's title at the organization. */
title?: string;
}
/**
* @hidden
*/
export class ContactOrganization implements IContactOrganization {
constructor(
public type?: string,
public name?: string,
public department?: string,
public title?: string,
public pref?: boolean
) {}
}
/** Search options to filter navigator.contacts. */
export interface IContactFindOptions {
/** The search string used to find navigator.contacts. */
filter?: string;
/** Determines if the find operation returns multiple navigator.contacts. Defaults to false. */
multiple?: boolean;
/** Contact fields to be returned back. If specified, the resulting Contact object only features values for these fields. */
desiredFields?: string[];
/**
* (Android only): Filters the search to only return contacts with a phone number informed.
*/
hasPhoneNumber?: boolean;
}
/**
* @hidden
*/
export class ContactFindOptions implements IContactFindOptions {
constructor(public filter?: string,
public multiple?: boolean,
public desiredFields?: string[],
public hasPhoneNumber?: boolean) {}
}
/**
* @name Contacts
* @description
* Access and manage Contacts on the device.
*
* @usage
*
* ```typescript
* import { Contacts, Contact, ContactField, ContactName } from '@ionic-native/contacts';
*
* constructor(private contacts: Contacts) { }
*
* let contact: Contact = this.contacts.create();
*
* contact.name = new ContactName(null, 'Smith', 'John');
* contact.phoneNumbers = [new ContactField('mobile', '6471234567')];
* contact.save().then(
* () => console.log('Contact saved!', contact),
* (error: any) => console.error('Error saving contact.', error)
* );
*
* ```
* @classes
* Contact
* @interfaces
* IContactProperties
* IContactError
* IContactName
* IContactField
* IContactAddress
* IContactOrganization
* IContactFindOptions
*/
@Plugin({
pluginName: 'Contacts',
plugin: 'cordova-plugin-contacts',
pluginRef: 'navigator.contacts',
repo: 'https://github.com/apache/cordova-plugin-contacts'
})
@Injectable()
export class Contacts {
/**
* Create a single contact.
* @returns {Contact} Returns a Contact object
*/
create(): Contact {
return new Contact();
}
/**
* Search for contacts in the Contacts list.
* @param fields {ContactFieldType[]} Contact fields to be used as a search qualifier
* @param options {IContactFindOptions} Optional options for the query
* @returns {Promise<Contact[]>} Returns a Promise that resolves with the search results (an array of Contact objects)
*/
find(fields: ContactFieldType[], options?: IContactFindOptions): Promise<Contact[]> {
return getPromise((resolve, reject) => {
navigator.contacts.find(fields, (contacts) => {
resolve(contacts.map(processContact));
}, reject, options);
});
}
/**
* Select a single Contact.
* @returns {Promise<Contact>} Returns a Promise that resolves with the selected Contact
*/
pickContact(): Promise<Contact> {
return getPromise((resolve, reject) => {
navigator.contacts.pickContact((contact) => resolve(processContact(contact)), reject);
});
}
}
/**
* @hidden
*/
function processContact(contact) {
let newContact = new Contact();
for (let prop in contact) {
if (typeof contact[prop] === 'function') continue;
newContact[prop] = contact[prop];
}
return newContact;
}
src/@ionic-native/plugins/couchbase-lite/index.ts
+42
View File
@@ -0,0 +1,42 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Injectable } from '@angular/core';
/**
* @name Couchbase Lite
* @description
* Plugin to install Couchbase Lite in your PhoneGap app on iOS or Android
*
* @usage
* ```
* import { CouchbaseLite } from '@ionic-native/couchbase-lite';
*
* constructor(private couchbase: CouchbaseLite) {
*
* couchbase.getURL()
* .then(url => console.log(url))
* .catch(error => console.error(error));
*
* }
*
* ```
*/
@Plugin({
pluginName: 'CouchbaseLite',
plugin: 'https://github.com/couchbaselabs/Couchbase-Lite-PhoneGap-Plugin',
pluginRef: 'cblite',
repo: 'https://github.com/couchbaselabs/Couchbase-Lite-PhoneGap-Plugin',
})
@Injectable()
export class CouchbaseLite {
/**
* Get the database url
* @return {Promise<any>} Returns a promise that resolves with the local database url
*/
@Cordova({
callbackStyle: 'node'
})
getURL(): Promise<any> { return; }
}
src/@ionic-native/plugins/crop/index.ts
+42
View File
@@ -0,0 +1,42 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Crop
* @description Crops images
* @usage
* ```
* import {Crop} from '@ionic-native/crop';
*
* constructor(private crop: Crop) { }
*
* ...
*
* this.crop.crop('path/to/image.jpg', {quality: 75})
* .then(
* newImage => console.log("new image path is: " + newImage),
* error => console.error("Error cropping image", error)
* );
* ```
*/
@Plugin({
pluginName: 'Crop',
plugin: 'cordova-plugin-crop',
pluginRef: 'plugins',
repo: 'https://github.com/jeduan/cordova-plugin-crop'
})
@Injectable()
export class Crop {
/**
* Crops an image
* @param pathToImage
* @param options
* @returns {Promise<string>} Returns a promise that resolves with the new image path, or rejects if failed to crop.
*/
@Cordova({
callbackOrder: 'reverse'
})
crop(pathToImage: string, options?: {quality: number}): Promise<string> { return; }
}
src/@ionic-native/plugins/date-picker/index.ts
+180
View File
@@ -0,0 +1,180 @@
import { Injectable } from '@angular/core';
import {Cordova, Plugin} from '@ionic-native/core';
export interface DatePickerOptions {
/**
* The mode of the date picker
* Values: date | time | datetime
*/
mode: string;
/**
* Selected date
*/
date: Date | string | number;
/**
* Minimum date
* Default: empty String
*/
minDate?: Date | string | number;
/**
* Maximum date
* Default?: empty String
*/
maxDate?: Date | string | number;
/**
* Label for the dialog title. If empty, uses android default (Set date/Set time).
* Default?: empty String
*/
titleText?: string;
/**
* Label of BUTTON_POSITIVE (done button) on Android
*/
okText?: string;
/**
* Label of BUTTON_NEGATIVE (cancel button). If empty, uses android.R.string.cancel.
*/
cancelText?: string;
/**
* Label of today button. If empty, doesn't show the option to select current date.
*/
todayText?: string;
/**
* Label of now button. If empty, doesn't show the option to select current time.
*/
nowText?: string;
/**
* Shows time dialog in 24 hours format.
*/
is24Hour?: boolean;
/**
* Choose the Android theme for the picker. You can use the DatePicker.ANDROID_THEMES property.
* Values: 1: THEME_TRADITIONAL | 2: THEME_HOLO_DARK | 3: THEME_HOLO_LIGHT | 4: THEME_DEVICE_DEFAULT_DARK | 5: THEME_DEVICE_DEFAULT_LIGHT
*/
androidTheme?: number;
/**
* Shows or hide dates earlier then selected date.
*/
allowOldDates?: boolean;
/**
* Shows or hide dates after selected date.
*/
allowFutureDates?: boolean;
/**
* Label of done button.
*/
doneButtonLabel?: string;
/**
* Hex color of done button.
*/
doneButtonColor?: string;
/**
* Label of cancel button.
*/
cancelButtonLabel?: string;
/**
* Hex color of cancel button.
*/
cancelButtonColor?: string;
/**
* X position of date picker. The position is absolute to the root view of the application.
*/
x?: number;
/**
* Y position of date picker. The position is absolute to the root view of the application.
*/
y?: number;
/**
* Interval between options in the minute section of the date picker.
*/
minuteInterval?: number;
/**
* Force the UIPopoverArrowDirection enum. The value any will revert to default UIPopoverArrowDirectionAny and let the app choose the proper direction itself.
*/
popoverArrowDirection?: string;
/**
* Force locale for datePicker.
*/
locale?: string;
}
/**
* @name Date Picker
* @description
* The DatePicker plugin allows the user to fetch date or time using native dialogs.
*
* @usage
* ```typescript
* import { DatePicker } from '@ionic-native/date-picker';
*
* constructor(private datePicker: DatePicker) { }
*
*
* ...
*
*
* this.datePicker.show({
* date: new Date(),
* mode: 'date',
* androidTheme: this.datePicker.ANDROID_THEMES.THEME_HOLO_DARK
* }).then(
* date => console.log('Got date: ', date),
* err => console.log('Error occurred while getting date: ', err)
* );
* ```
* @interfaces
* DatePickerOptions
*/
@Plugin({
pluginName: 'DatePicker',
plugin: 'cordova-plugin-datepicker',
pluginRef: 'datePicker',
repo: 'https://github.com/VitaliiBlagodir/cordova-plugin-datepicker',
platforms: ['Android', 'iOS', 'Windows']
})
@Injectable()
export class DatePicker {
/**
* @hidden
*/
ANDROID_THEMES = {
THEME_TRADITIONAL: 1,
THEME_HOLO_DARK: 2,
THEME_HOLO_LIGHT: 3,
THEME_DEVICE_DEFAULT_DARK: 4,
THEME_DEVICE_DEFAULT_LIGHT: 5
};
/**
* Shows the date and/or time picker dialog(s)
* @param {DatePickerOptions} options Options for the date picker.
* @returns {Promise<Date>} Returns a promise that resolves with the picked date and/or time, or rejects with an error.
*/
@Cordova()
show(options: DatePickerOptions): Promise<Date> {
return;
}
}
src/@ionic-native/plugins/db-meter/index.ts
+78
View File
@@ -0,0 +1,78 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
/**
* @name DB Meter
* @description This plugin defines a global DBMeter object, which permits to get the decibel values from the microphone.
* @usage
* ```typescript
* import { DBMeter } from '@ionic-native/db-meter';
*
* constructor(private dbMeter: DBMeter) { }
*
* ...
*
*
* // Start listening
* let subscription = this.dbMeter.start().subscribe(
* data => console.log(data)
* );
*
* // Check if we are listening
* this.dbMeter.isListening().then(
* (isListening: boolean) => console.log(isListening)
* );
*
* // Stop listening
* subscription.unsubscribe();
*
* // Delete DBMeter instance from memory
* this.dbMeter.delete().then(
* () => console.log('Deleted DB Meter instance'),
* error => console.log('Error occurred while deleting DB Meter instance')
* );
* ```
*/
@Plugin({
pluginName: 'DBMeter',
plugin: 'cordova-plugin-dbmeter',
pluginRef: 'DBMeter',
repo: 'https://github.com/akofman/cordova-plugin-dbmeter',
platforms: ['iOS', 'Android']
})
@Injectable()
export class DBMeter {
/**
* Starts listening
* @returns {Observable<any>} Returns an observable. Subscribe to start listening. Unsubscribe to stop listening.
*/
@Cordova({
observable: true,
clearFunction: 'stop'
})
start(): Observable<any> { return; }
/**
* Stops listening
* @hidden
*/
@Cordova()
stop(): Promise<any> { return; }
/**
* Check if the DB Meter is listening
* @returns {Promise<boolean>} Returns a promise that resolves with a boolean that tells us whether the DB meter is listening
*/
@Cordova()
isListening(): Promise<boolean> { return; }
/**
* Delete the DB Meter instance
* @returns {Promise<any>} Returns a promise that will resolve if the instance has been deleted, and rejects if errors occur.
*/
@Cordova()
delete(): Promise<any> { return; }
}
src/@ionic-native/plugins/deeplinks/index.ts
+126
View File
@@ -0,0 +1,126 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export interface DeeplinkMatch {
/**
* The route info for the matched route
*/
$route: any;
/**
* Any arguments passed either through route parameters or GET parameters
*/
$args: any;
/**
* The deeplink object processed from the plugin, along with any
* any internal native data available as "extras" at the time
* the route was matched (for example, Facebook sometimes adds extra data)
*/
$link: any;
}
/**
* @name Ionic Deeplinks
* @description This plugin handles deeplinks on iOS and Android for both custom URL scheme links
* and Universal App Links.
*
* @usage
* ```typescript
* import { Deeplinks } from '@ionic-native/deeplinks';
*
* constructor(private deepLinks: DeepLinks) { }
*
* this.deepLinks.route({
* '/about-us': AboutPage,
* '/universal-links-test': AboutPage,
* '/products/:productId': ProductPage
* }).subscribe((match) => {
* // match.$route - the route we matched, which is the matched entry from the arguments to route()
* // match.$args - the args passed in the link
* // match.$link - the full link data
* console.log('Successfully matched route', match);
* }, (nomatch) => {
* // nomatch.$link - the full link data
* console.error('Got a deeplink that didn\'t match', nomatch);
* });
* ```
*
* Alternatively, if you're using Ionic 2, there's a convenience method that takes a reference to a `NavController` and handles
* the actual navigation for you:
*
* ```typescript
* this.deepLinks.routeWithNavController(this.navController, {
* '/about-us': AboutPage,
* '/products/:productId': ProductPage
* }).subscribe((match) => {
* // match.$route - the route we matched, which is the matched entry from the arguments to route()
* // match.$args - the args passed in the link
* // match.$link - the full link data
* console.log('Successfully matched route', match);
* }, (nomatch) => {
* // nomatch.$link - the full link data
* console.error('Got a deeplink that didn\'t match', nomatch);
* });
* ```
*
* See the [Ionic 2 Deeplinks Demo](https://github.com/driftyco/ionic2-deeplinks-demo/blob/master/app/app.ts) for an example of how to
* retrieve the `NavController` reference at runtime.
*
* @interfaces
* DeeplinkMatch
*/
@Plugin({
pluginName: 'Deeplinks',
plugin: 'ionic-plugin-deeplinks',
pluginRef: 'IonicDeeplink',
repo: 'https://github.com/driftyco/ionic-plugin-deeplinks',
platforms: ['iOS', 'Android'],
install: 'ionic plugin add ionic-plugin-deeplinks --variable URL_SCHEME=myapp --variable DEEPLINK_SCHEME=https --variable DEEPLINK_HOST=example.com --variable ANDROID_PATH_PREFIX=/',
installVariables: ['URL_SCHEME', 'DEEPLINK_SCHEME', 'DEEPLINK_HOST', 'ANDROID_PATH_PREFIX']
})
@Injectable()
export class Deeplinks {
/**
* Define a set of paths to match against incoming deeplinks.
*
* @param {paths} Define a set of paths to match against incoming deeplinks.
* paths takes an object of the form { 'path': data }. If a deeplink
* matches the path, the resulting path-data pair will be returned in the
* promise result which you can then use to navigate in the app as you see fit.
* @returns {Observable<DeeplinkMatch>} Returns an Observable that is called each time a deeplink comes through, and
* errors if a deeplink comes through that does not match a given path.
*/
@Cordova({
observable: true
})
route(paths): Observable<DeeplinkMatch> { return; }
/**
*
* This is a convenience version of `route` that takes a reference to a NavController
* from Ionic 2, or a custom class that conforms to this protocol:
*
* NavController.push = function(View, Params){}
*
* This handler will automatically navigate when a route matches. If you need finer-grained
* control over the behavior of a matching deeplink, use the plain `route` method.
*
* @param {paths} Define a set of paths to match against incoming deeplinks.
* paths takes an object of the form { 'path': data }. If a deeplink
* matches the path, the resulting path-data pair will be returned in the
* promise result which you can then use to navigate in the app as you see fit.
*
* @returns {Observable<DeeplinkMatch>} Returns an Observable that resolves each time a deeplink comes through, and
* errors if a deeplink comes through that does not match a given path.
*/
@Cordova({
observable: true
})
routeWithNavController(navController, paths): Observable<DeeplinkMatch> { return; }
}
src/@ionic-native/plugins/device-accounts/index.ts
+61
View File
@@ -0,0 +1,61 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Device Accounts
* @description
* Gets the Google accounts associated with the Android device
*
* @usage
* ```typescript
* import { DeviceAccounts } from '@ionic-native/device-accounts';
*
* constructor(private deviceAccounts: DeviceAccounts) { }
*
* ...
*
* this.deviceAccounts.get()
* .then(accounts => console.log(accounts))
* .catch(error => console.error(error));
*
* ```
*/
@Plugin({
pluginName: 'DeviceAccounts',
plugin: 'https://github.com/loicknuchel/cordova-device-accounts.git',
pluginRef: 'plugins.DeviceAccounts',
repo: 'https://github.com/loicknuchel/cordova-device-accounts',
platforms: ['Android']
})
@Injectable()
export class DeviceAccounts {
/**
* Gets all accounts registered on the Android Device
* @returns {Promise<any>}
*/
@Cordova()
get(): Promise<any> { return; }
/**
* Get all accounts registered on Android device for requested type
* @returns {Promise<any>}
*/
@Cordova()
getByType(type: string): Promise<any> { return; }
/**
* Get all emails registered on Android device (accounts with 'com.google' type)
* @returns {Promise<any>}
*/
@Cordova()
getEmails(): Promise<any> { return; }
/**
* Get the first email registered on Android device
* @returns {Promise<any>}
*/
@Cordova()
getEmail(): Promise<any> { return; }
}
src/@ionic-native/plugins/device-feedback/index.ts
+63
View File
@@ -0,0 +1,63 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Device Feedback
* @description
*
* Plugin that lets you provide haptic or acoustic feedback on Android devices.
*
* @usage
* ```
* import { DeviceFeedback } from '@ionic-native/device-feedback';
*
* constructor(private deviceFeedback: DeviceFeedback) { }
*
* ...
*
*
* this.deviceFeedback.acoustic();
*
* this.deviceFeedback.haptic(0);
*
* this.deviceFeedback.isFeedbackEnabled()
* .then((feedback) => {
* console.log(feedback);
* // {
* // acoustic: true,
* // haptic: true
* // }
* });
*
* ```
*/
@Plugin({
pluginName: 'DeviceFeedback',
plugin: 'cordova-plugin-velda-devicefeedback',
pluginRef: 'plugins.deviceFeedback',
repo: 'https://github.com/VVelda/device-feedback',
platforms: ['Android']
})
@Injectable()
export class DeviceFeedback {
/**
* Provide sound feedback to user, nevertheless respect user's settings and current active device profile as native feedback do.
*/
@Cordova({ sync: true })
acoustic(): void { }
/**
* Provide vibrate feedback to user, nevertheless respect user's tactile feedback setting as native feedback do.
* @param type {Number} Specify type of vibration feedback. 0 for long press, 1 for virtual key, or 3 for keyboard tap.
*/
@Cordova({ sync: true })
haptic(type: number): void { }
/**
* Check if haptic and acoustic feedback is enabled by user settings.
* @returns {Promise<any>}
*/
@Cordova()
isFeedbackEnabled(): Promise<{ haptic: boolean; acoustic: boolean; }> { return; }
}
src/@ionic-native/plugins/device-motion/index.ts
+98
View File
@@ -0,0 +1,98 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export interface DeviceMotionAccelerationData {
/**
* Amount of acceleration on the x-axis. (in m/s^2)
*/
x: number;
/**
* Amount of acceleration on the y-axis. (in m/s^2)
*/
y: number;
/**
* Amount of acceleration on the z-axis. (in m/s^2)
*/
z: number;
/**
* Creation timestamp in milliseconds.
*/
timestamp: any;
}
export interface DeviceMotionAccelerometerOptions {
/**
* Requested period of calls to accelerometerSuccess with acceleration data in Milliseconds. Default: 10000
*/
frequency?: number;
}
/**
* @name Device Motion
* @description
* Requires Cordova plugin: `cordova-plugin-device-motion`. For more info, please see the [Device Motion docs](https://github.com/apache/cordova-plugin-device-motion).
*
* @usage
* ```typescript
* import { DeviceMotion, DeviceMotionAccelerationData } from '@ionic-native/device-motion';
*
* constructor(private deviceMotion: DeviceMotion) { }
*
* ...
*
* // Get the device current acceleration
* this.deviceMotion.getCurrentAcceleration().then(
* (acceleration: DeviceMotionAccelerationData) => console.log(acceleration),
* (error: any) => console.log(error)
* );
*
* // Watch device acceleration
* var subscription = this.deviceMotion.watchAcceleration().subscribe((acceleration: DeviceMotionAccelerationData) => {
* console.log(acceleration);
* });
*
* // Stop watch
* subscription.unsubscribe();
*
* ```
* @interfaces
* DeviceMotionAccelerationData
* DeviceMotionAccelerometerOptions
*/
@Plugin({
pluginName: 'DeviceMotion',
plugin: 'cordova-plugin-device-motion',
pluginRef: 'navigator.accelerometer',
repo: 'https://github.com/apache/cordova-plugin-device-motion'
})
@Injectable()
export class DeviceMotion {
/**
* Get the current acceleration along the x, y, and z axes.
* @returns {Promise<DeviceMotionAccelerationData>} Returns object with x, y, z, and timestamp properties
*/
@Cordova()
getCurrentAcceleration(): Promise<DeviceMotionAccelerationData> { return; }
/**
* Watch the device acceleration. Clear the watch by unsubscribing from the observable.
* @param {AccelerometerOptions} options list of options for the accelerometer.
* @returns {Observable<DeviceMotionAccelerationData>} Observable returns an observable that you can subscribe to
*/
@Cordova({
callbackOrder: 'reverse',
observable: true,
clearFunction: 'clearWatch'
})
watchAcceleration(options?: DeviceMotionAccelerometerOptions): Observable<DeviceMotionAccelerationData> { return; }
}
src/@ionic-native/plugins/device-orientation/index.ts
+105
View File
@@ -0,0 +1,105 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export interface DeviceOrientationCompassHeading {
/**
* The heading in degrees from 0-359.99 at a single moment in time. (Number)
*/
magneticHeading: number;
/**
* The heading relative to the geographic North Pole in degrees 0-359.99 at a single moment in time. A negative value indicates that the true heading can't be determined. (Number)
*/
trueHeading: number;
/**
* The deviation in degrees between the reported heading and the true heading. (Number)
*/
headingAccuracy: number;
/**
* The time at which this heading was determined. (DOMTimeStamp)
*/
timestamp: any;
}
export interface DeviceOrientationCompassOptions {
/**
* How often to retrieve the compass heading in milliseconds. (Number) (Default: 100)
*/
frequency?: number;
/**
* The change in degrees required to initiate a watchHeading success callback. When this value is set, frequency is ignored. (Number)
*/
filter?: number;
}
/**
* @name Device Orientation
* @description
* Requires Cordova plugin: `cordova-plugin-device-orientation`. For more info, please see the [Device Orientation docs](https://github.com/apache/cordova-plugin-device-orientation).
*
* @usage
* ```typescript
* // DeviceOrientationCompassHeading is an interface for compass
* import { DeviceOrientation, DeviceOrientationCompassHeading } from '@ionic-native/device-orientation';
*
* constructor(private deviceOrientation: DeviceOrientation) { }
*
* ...
*
* // Get the device current compass heading
* this.deviceOrientation.getCurrentHeading().then(
* (data: DeviceOrientationCompassHeading) => console.log(data),
* (error: any) => console.log(error)
* );
*
* // Watch the device compass heading change
* var subscription = this.deviceOrientation.watchHeading().subscribe(
* (data: DeviceOrientationCompassHeading) => console.log(data)
* );
*
* // Stop watching heading change
* subscription.unsubscribe();
* ```
* @interfaces
* DeviceOrientationCompassOptions
* DeviceOrientationCompassHeading
*/
@Plugin({
pluginName: 'DeviceOrientation',
plugin: 'cordova-plugin-device-orientation',
pluginRef: 'navigator.compass',
repo: 'https://github.com/apache/cordova-plugin-device-orientation'
})
@Injectable()
export class DeviceOrientation {
/**
* Get the current compass heading.
* @returns {Promise<DeviceOrientationCompassHeading>}
*/
@Cordova()
getCurrentHeading(): Promise<DeviceOrientationCompassHeading> { return; }
/**
* Get the device current heading at a regular interval
*
* Stop the watch by unsubscribing from the observable
* @param {DeviceOrientationCompassOptions} options Options for compass. Frequency and Filter. Optional
* @returns {Observable<DeviceOrientationCompassHeading>} Returns an observable that contains the compass heading
*/
@Cordova({
callbackOrder: 'reverse',
observable: true,
clearFunction: 'clearWatch'
})
watchHeading(options?: DeviceOrientationCompassOptions): Observable<DeviceOrientationCompassHeading> { return; }
}
src/@ionic-native/plugins/device/index.ts
+66
View File
@@ -0,0 +1,66 @@
import { Injectable } from '@angular/core';
import { CordovaProperty, Plugin } from '@ionic-native/core';
declare var window: any;
/**
* @name Device
* @description
* Access information about the underlying device and platform.
*
* @usage
* ```typescript
* import { Device } from '@ionic-native/device';
*
* constructor(private device: Device) { }
*
* ...
*
* console.log('Device UUID is: ' + this.device.uuid);
* ```
*/
@Plugin({
pluginName: 'Device',
plugin: 'cordova-plugin-device',
pluginRef: 'device',
repo: 'https://github.com/apache/cordova-plugin-device'
})
@Injectable()
export class Device {
/** Get the version of Cordova running on the device. */
@CordovaProperty
cordova: string;
/**
* The device.model returns the name of the device's model or product. The value is set
* by the device manufacturer and may be different across versions of the same product.
*/
@CordovaProperty
model: string;
/** Get the device's operating system name. */
@CordovaProperty
platform: string;
/** Get the device's Universally Unique Identifier (UUID). */
@CordovaProperty
uuid: string;
/** Get the operating system version. */
@CordovaProperty
version: string;
/** Get the device's manufacturer. */
@CordovaProperty
manufacturer: string;
/** Whether the device is running on a simulator. */
@CordovaProperty
isVirtual: boolean;
/** Get the device hardware serial number. */
@CordovaProperty
serial: string;
}
src/@ionic-native/plugins/diagnostic/index.ts
+723
View File
@@ -0,0 +1,723 @@
import { Injectable } from '@angular/core';
import {Cordova, Plugin, CordovaProperty} from '@ionic-native/core';
/**
* @name Diagnostic
* @description
* Checks whether device hardware features are enabled or available to the app, e.g. camera, GPS, wifi
*
* @usage
* ```typescript
* import { Diagnostic } from '@ionic-native/diagnostic';
*
* constructor(private diagnostic: Diagnostic) { }
*
* ...
*
* let successCallback = (isAvailable) => { console.log('Is available? ' + isAvailable); };
* let errorCallback = (e) => console.error(e);
*
* this.diagnostic.isCameraAvailable().then(successCallback).catch(errorCallback);
*
* this.diagnostic.isBluetoothAvailable().then(successCallback, errorCallback);
*
*
* this.diagnostic.getBluetoothState()
* .then((state) => {
* if (state == this.diagnostic.bluetoothState.POWERED_ON){
* // do something
* } else {
* // do something else
* }
* }).catch(e => console.error(e));
*
* ```
*
*/
@Plugin({
pluginName: 'Diagnostic',
plugin: 'cordova.plugins.diagnostic',
pluginRef: 'cordova.plugins.diagnostic',
repo: 'https://github.com/dpa99c/cordova-diagnostic-plugin'
})
@Injectable()
export class Diagnostic {
permission = {
READ_CALENDAR: 'READ_CALENDAR',
WRITE_CALENDAR: 'WRITE_CALENDAR',
CAMERA: 'CAMERA',
READ_CONTACTS: 'READ_CONTACTS',
WRITE_CONTACTS: 'WRITE_CONTACTS',
GET_ACCOUNTS: 'GET_ACCOUNTS',
ACCESS_FINE_LOCATION: 'ACCESS_FINE_LOCATION',
ACCESS_COARSE_LOCATION: 'ACCESS_COARSE_LOCATION',
RECORD_AUDIO: 'RECORD_AUDIO',
READ_PHONE_STATE: 'READ_PHONE_STATE',
CALL_PHONE: 'CALL_PHONE',
ADD_VOICEMAIL: 'ADD_VOICEMAIL',
USE_SIP: 'USE_SIP',
PROCESS_OUTGOING_CALLS: 'PROCESS_OUTGOING_CALLS',
READ_CALL_LOG: 'READ_CALL_LOG',
WRITE_CALL_LOG: 'WRITE_CALL_LOG',
SEND_SMS: 'SEND_SMS',
RECEIVE_SMS: 'RECEIVE_SMS',
READ_SMS: 'READ_SMS',
RECEIVE_WAP_PUSH: 'RECEIVE_WAP_PUSH',
RECEIVE_MMS: 'RECEIVE_MMS',
WRITE_EXTERNAL_STORAGE: 'WRITE_EXTERNAL_STORAGE',
READ_EXTERNAL_STORAGE: 'READ_EXTERNAL_STORAGE',
BODY_SENSORS: 'BODY_SENSORS'
};
@CordovaProperty
permissionStatus: {
GRANTED: string;
DENIED: string;
NOT_REQUESTED: string;
DENIED_ALWAYS: string;
RESTRICTED: string;
GRANTED_WHEN_IN_USE: string;
};
locationAuthorizationMode = {
ALWAYS: 'always',
WHEN_IN_USE: 'when_in_use'
};
permissionGroups = {
CALENDAR: ['READ_CALENDAR', 'WRITE_CALENDAR'],
CAMERA: ['CAMERA'],
CONTACTS: ['READ_CONTACTS', 'WRITE_CONTACTS', 'GET_ACCOUNTS'],
LOCATION: ['ACCESS_FINE_LOCATION', 'ACCESS_COARSE_LOCATION'],
MICROPHONE: ['RECORD_AUDIO'],
PHONE: ['READ_PHONE_STATE', 'CALL_PHONE', 'ADD_VOICEMAIL', 'USE_SIP', 'PROCESS_OUTGOING_CALLS', 'READ_CALL_LOG', 'WRITE_CALL_LOG'],
SENSORS: ['BODY_SENSORS'],
SMS: ['SEND_SMS', 'RECEIVE_SMS', 'READ_SMS', 'RECEIVE_WAP_PUSH', 'RECEIVE_MMS'],
STORAGE: ['READ_EXTERNAL_STORAGE', 'WRITE_EXTERNAL_STORAGE']
};
locationMode = {
HIGH_ACCURACY: 'high_accuracy',
DEVICE_ONLY: 'device_only',
BATTERY_SAVING: 'battery_saving',
LOCATION_OFF: 'location_off'
};
bluetoothState = {
UNKNOWN: 'unknown',
RESETTING: 'resetting', // iOS
UNSUPPORTED: 'unsupported', // iOS
UNAUTHORIZED: 'unauthorized', // iOS
POWERED_OFF: 'powered_off',
POWERED_ON: 'powered_on',
POWERING_OFF: 'powering_off',
POWERING_ON: 'powering_on'
};
@CordovaProperty
NFCState: {
UNKNOWN: string;
POWERED_OFF: string;
POWERED_ON: string;
POWERING_ON: string;
POWERING_OFF: string;
};
/**
* Checks if app is able to access device location.
* @returns {Promise<any>}
*/
@Cordova()
isLocationAvailable(): Promise<any> { return; }
/**
* Checks if Wifi is connected/enabled. On iOS this returns true if the device is connected to a network by WiFi. On Android and Windows 10 Mobile this returns true if the WiFi setting is set to enabled.
* On Android this requires permission. `<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />`
* @returns {Promise<any>}
*/
@Cordova()
isWifiAvailable(): Promise<any> { return; }
/**
* Checks if the device has a camera. On Android this returns true if the device has a camera. On iOS this returns true if both the device has a camera AND the application is authorized to use it. On Windows 10 Mobile this returns true if both the device has a rear-facing camera AND the
* application is authorized to use it.
* @returns {Promise<any>}
*/
@Cordova()
isCameraAvailable(): Promise<any> { return; }
/**
* Checks if the device has Bluetooth capabilities and if so that Bluetooth is switched on (same on Android, iOS and Windows 10 Mobile)
* On Android this requires permission <uses-permission android:name="android.permission.BLUETOOTH" />
* @returns {Promise<any>}
*/
@Cordova()
isBluetoothAvailable(): Promise<any> { return; }
/**
* Displays the device location settings to allow user to enable location services/change location mode.
*/
@Cordova({ sync: true, platforms: ['Android', 'Windows 10'] })
switchToLocationSettings(): void { }
/**
* Displays mobile settings to allow user to enable mobile data.
*/
@Cordova({ sync: true, platforms: ['Android', 'Windows 10'] })
switchToMobileDataSettings(): void { }
/**
* Displays Bluetooth settings to allow user to enable Bluetooth.
*/
@Cordova({ sync: true, platforms: ['Android', 'Windows 10'] })
switchToBluetoothSettings(): void { }
/**
* Displays WiFi settings to allow user to enable WiFi.
*/
@Cordova({ sync: true, platforms: ['Android', 'Windows 10'] })
switchToWifiSettings(): void { }
/**
* Returns true if the WiFi setting is set to enabled, and is the same as `isWifiAvailable()`
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android', 'Windows 10'] })
isWifiEnabled(): Promise<boolean> { return; }
/**
* Enables/disables WiFi on the device.
* Requires `ACCESS_WIFI_STATE` and `CHANGE_WIFI_STATE` permissions on Android
* @param state {boolean}
* @returns {Promise<any>}
*/
@Cordova({ callbackOrder: 'reverse', platforms: ['Android', 'Windows 10'] })
setWifiState(state: boolean): Promise<any> { return; }
/**
* Enables/disables Bluetooth on the device.
* Requires `BLUETOOTH` and `BLUETOOTH_ADMIN` permissions on Android
* @param state {boolean}
* @returns {Promise<any>}
*/
@Cordova({ callbackOrder: 'reverse', platforms: ['Android', 'Windows 10'] })
setBluetoothState(state: boolean): Promise<any> { return; }
// ANDROID AND IOS ONLY
/**
* Returns true if the device setting for location is on. On Android this returns true if Location Mode is switched on. On iOS this returns true if Location Services is switched on.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
isLocationEnabled(): Promise<boolean> { return; }
/**
* Checks if the application is authorized to use location.
* Note for Android: this is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
* @returns {Promise<any>}
*/
@Cordova()
isLocationAuthorized(): Promise<any> { return; }
/**
* Returns the location authorization status for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
getLocationAuthorizationStatus(): Promise<any> { return; }
/**
* Returns the location authorization status for the application.
* Note for Android: this is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
*
* mode - (iOS-only / optional) location authorization mode: "always" or "when_in_use". If not specified, defaults to "when_in_use".
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'], callbackOrder: 'reverse' })
requestLocationAuthorization(mode?: string): Promise<any> { return; }
/**
* Checks if camera hardware is present on device.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
isCameraPresent(): Promise<any> { return; }
/**
* Checks if the application is authorized to use the camera.
* Note for Android: this is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will always return TRUE as permissions are already granted at installation time.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
isCameraAuthorized(): Promise<any> { return; }
/**
* Returns the camera authorization status for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
getCameraAuthorizationStatus(): Promise<any> { return; }
/**
* Requests camera authorization for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
requestCameraAuthorization(): Promise<any> { return; }
/**
* Checks if the application is authorized to use the microphone.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
isMicrophoneAuthorized(): Promise<boolean> { return; }
/**
* Returns the microphone authorization status for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
getMicrophoneAuthorizationStatus(): Promise<any> { return; }
/**
* Requests microphone authorization for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
requestMicrophoneAuthorization(): Promise<any> { return; }
/**
* Checks if the application is authorized to use contacts (address book).
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
isContactsAuthorized(): Promise<boolean> { return; }
/**
* Returns the contacts authorization status for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
getContactsAuthorizationStatus(): Promise<any> { return; }
/**
* Requests contacts authorization for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
requestContactsAuthorization(): Promise<any> { return; }
/**
* Checks if the application is authorized to use the calendar.
*
* Notes for Android:
* - This is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will always return TRUE as permissions are already granted at installation time.
*
* Notes for iOS:
* - This relates to Calendar Events (not Calendar Reminders)
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
isCalendarAuthorized(): Promise<boolean> { return; }
/**
* Returns the calendar authorization status for the application.
*
* Notes for Android:
* - This is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will always return `GRANTED` status as permissions are already granted at installation time.
*
* Notes for iOS:
* - This relates to Calendar Events (not Calendar Reminders)
*
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
getCalendarAuthorizationStatus(): Promise<any> { return; }
/**
* Requests calendar authorization for the application.
*
* Notes for iOS:
* - Should only be called if authorization status is NOT_DETERMINED. Calling it when in any other state will have no effect and just return the current authorization status.
* - This relates to Calendar Events (not Calendar Reminders)
*
* Notes for Android:
* - This is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will have no effect as the permissions are already granted at installation time.
* - This requests permission for `READ_CALENDAR` run-time permission
* - Required permissions must be added to `AndroidManifest.xml` as appropriate - see Android permissions: `READ_CALENDAR`, `WRITE_CALENDAR`
*
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
requestCalendarAuthorization(): Promise<any> { return; }
/**
* Opens settings page for this app.
* On Android, this opens the "App Info" page in the Settings app.
* On iOS, this opens the app settings page in the Settings app. This works only on iOS 8+ - iOS 7 and below will invoke the errorCallback.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
switchToSettings(): Promise<any> { return; }
/**
* Returns the state of Bluetooth on the device.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android', 'iOS'] })
getBluetoothState(): Promise<any> { return; }
/**
* Registers a function to be called when a change in Bluetooth state occurs.
* @param handler
*/
@Cordova({ platforms: ['Android', 'iOS'], sync: true })
registerBluetoothStateChangeHandler(handler: Function): void { }
/**
* Registers a function to be called when a change in Location state occurs.
* @param handler
*/
@Cordova({ platforms: ['Android', 'iOS'], sync: true })
registerLocationStateChangeHandler(handler: Function): void { }
// ANDROID ONLY
/**
* Checks if high-accuracy locations are available to the app from GPS hardware.
* Returns true if Location mode is enabled and is set to "Device only" or "High accuracy" AND if the app is authorised to use location.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
isGpsLocationAvailable(): Promise<boolean> { return; }
/**
* Checks if location mode is set to return high-accuracy locations from GPS hardware.
* Returns true if Location mode is enabled and is set to either:
* - Device only = GPS hardware only (high accuracy)
* - High accuracy = GPS hardware, network triangulation and Wifi network IDs (high and low accuracy)
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'] })
isGpsLocationEnabled(): Promise<any> { return; }
/**
* Checks if low-accuracy locations are available to the app from network triangulation/WiFi access points.
* Returns true if Location mode is enabled and is set to "Battery saving" or "High accuracy" AND if the app is authorised to use location.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'] })
isNetworkLocationAvailable(): Promise<any> { return; }
/**
* Checks if location mode is set to return low-accuracy locations from network triangulation/WiFi access points.
* Returns true if Location mode is enabled and is set to either:
* - Battery saving = network triangulation and Wifi network IDs (low accuracy)
* - High accuracy = GPS hardware, network triangulation and Wifi network IDs (high and low accuracy)
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'] })
isNetworkLocationEnabled(): Promise<any> { return; }
/**
* Returns the current location mode setting for the device.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'] })
getLocationMode(): Promise<any> { return; }
/**
* Returns the current authorisation status for a given permission.
* Note: this is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
* @param permission
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'], callbackOrder: 'reverse' })
getPermissionAuthorizationStatus(permission: any): Promise<any> { return; }
/**
* Returns the current authorisation status for multiple permissions.
* Note: this is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
* @param permissions
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'], callbackOrder: 'reverse' })
getPermissionsAuthorizationStatus(permissions: any[]): Promise<any> { return; }
/**
* Requests app to be granted authorisation for a runtime permission.
* Note: this is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will have no effect as the permissions are already granted at installation time.
* @param permission
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'], callbackOrder: 'reverse' })
requestRuntimePermission(permission: any): Promise<any> { return; }
/**
* Requests app to be granted authorisation for multiple runtime permissions.
* Note: this is intended for Android 6 / API 23 and above. Calling on Android 5 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
* @param permissions
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'], callbackOrder: 'reverse' })
requestRuntimePermissions(permissions: any[]): Promise<any> { return; }
/**
* Indicates if the plugin is currently requesting a runtime permission via the native API.
* Note that only one request can be made concurrently because the native API cannot handle concurrent requests,
* so the plugin will invoke the error callback if attempting to make more than one simultaneous request.
* Multiple permission requests should be grouped into a single call since the native API is setup to handle batch requests of multiple permission groups.
* @returns {boolean}
*/
@Cordova({ sync: true })
isRequestingPermission(): boolean { return; }
/**
* Registers a function to be called when a runtime permission request has completed.
* Pass in a falsey value to de-register the currently registered function.
* @param handler {Function}
*/
@Cordova({ sync: true })
registerPermissionRequestCompleteHandler(handler: Function): void { return; }
/**
* Checks if the device setting for Bluetooth is switched on.
* This requires `BLUETOOTH` permission on Android
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
isBluetoothEnabled(): Promise<boolean> { return; }
/**
* Checks if the device has Bluetooth capabilities.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
hasBluetoothSupport(): Promise<boolean> { return; }
/**
* Checks if the device has Bluetooth Low Energy (LE) capabilities.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
hasBluetoothLESupport(): Promise<boolean> { return; }
/**
* Checks if the device supports Bluetooth Low Energy (LE) Peripheral mode.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
hasBluetoothLEPeripheralSupport(): Promise<boolean> { return; }
/**
* Checks if the application is authorized to use external storage.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
isExternalStorageAuthorized(): Promise<boolean> { return; }
/**
* CReturns the external storage authorization status for the application.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
getExternalStorageAuthorizationStatus(): Promise<any> { return; }
/**
* Requests external storage authorization for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'] })
requestExternalStorageAuthorization(): Promise<any> { return; }
/**
* Returns details of external SD card(s): absolute path, is writable, free space.
*
* The intention of this method is to return the location and details of removable external SD cards.
* This differs from the "external directories" returned by cordova-plugin-file which return mount points relating to non-removable (internal) storage.
*
* Learn more about this method [here](https://github.com/dpa99c/cordova-diagnostic-plugin#getexternalsdcarddetails)
*
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'] })
getExternalSdCardDetails(): Promise<any> { return; }
/**
* Switches to the wireless settings page in the Settings app. Allows configuration of wireless controls such as Wi-Fi, Bluetooth and Mobile networks.
*/
@Cordova({
platforms: ['Android'],
sync: true
})
switchToWirelessSettings(): void { }
/**
* Displays NFC settings to allow user to enable NFC.
*/
@Cordova({
platforms: ['Android'],
sync: true
})
switchToNFCSettings(): void { }
/**
* Checks if NFC hardware is present on device.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
isNFCPresent(): Promise<boolean> { return; }
/**
* Checks if the device setting for NFC is switched on.
* Note: this operation does not require NFC permission in the manifest.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['Android'] })
isNFCEnabled(): Promise<boolean> { return; }
/**
* Checks if NFC is available to the app. Returns true if the device has NFC capabilities AND if NFC setting is switched on.
* Note: this operation does not require NFC permission in the manifest.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['Android'] })
isNFCAvailable(): Promise<boolean> { return; }
/**
* Registers a function to be called when a change in NFC state occurs. Pass in a falsey value to de-register the currently registered function.
* @param hander {Function} callback function to be called when NFC state changes
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['Android'],
sync: true
})
registerNFCStateChangeHandler(handler: Function): void { }
// IOS ONLY
/**
* Checks if the application is authorized to use the Camera Roll in Photos app.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['iOS'] })
isCameraRollAuthorized(): Promise<boolean> { return; }
/**
* Returns the authorization status for the application to use the Camera Roll in Photos app.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['iOS'] })
getCameraRollAuthorizationStatus(): Promise<boolean> { return; }
/**
* Requests camera roll authorization for the application.
* Should only be called if authorization status is NOT_REQUESTED.
* Calling it when in any other state will have no effect.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['iOS'] })
requestCameraRollAuthorization(): Promise<any> { return; }
/**
* Checks if remote (push) notifications are enabled.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['iOS'] })
isRemoteNotificationsEnabled(): Promise<boolean> { return; }
/**
* Indicates if the app is registered for remote (push) notifications on the device.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['iOS'] })
isRegisteredForRemoteNotifications(): Promise<boolean> { return; }
/**
* Indicates the current setting of notification types for the app in the Settings app.
* Note: on iOS 8+, if "Allow Notifications" switch is OFF, all types will be returned as disabled.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['iOS'] })
getRemoteNotificationTypes(): Promise<any> { return; }
/**
* Checks if the application is authorized to use reminders.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['iOS'] })
isRemindersAuthorized(): Promise<boolean> { return; }
/**
* Returns the reminders authorization status for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['iOS'] })
getRemindersAuthorizationStatus(): Promise<any> { return; }
/**
* Requests reminders authorization for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['iOS'] })
requestRemindersAuthorization(): Promise<any> { return; }
/**
* Checks if the application is authorized for background refresh.
* @returns {Promise<boolean>}
*/
@Cordova({ platforms: ['iOS'] })
isBackgroundRefreshAuthorized(): Promise<boolean> { return; }
/**
* Returns the background refresh authorization status for the application.
* @returns {Promise<any>}
*/
@Cordova({ platforms: ['iOS'] })
getBackgroundRefreshStatus(): Promise<any> { return; }
/**
* Requests Bluetooth authorization for the application.
*
* Learn more about this method [here](https://github.com/dpa99c/cordova-diagnostic-plugin#requestbluetoothauthorization)
* @return {Promise<any>}
*/
@Cordova({ platforms: ['iOS'] })
requestBluetoothAuthorization(): Promise<any> { return; }
/**
* Checks if motion tracking is available on the current device.
* @return {Promise<boolean>}
*/
@Cordova({ platforms: ['iOS'] })
isMotionAvailable(): Promise<boolean> { return; }
/**
* Checks if it's possible to determine the outcome of a motion authorization request on the current device.
* There's no direct way to determine if authorization was granted or denied, so the Pedometer API must be used to indirectly determine this:
* therefore, if the device supports motion tracking but not Pedometer Event Tracking, the outcome of requesting motion detection cannot be determined.
*
* @return {Promise<boolean>}
*/
@Cordova({ platforms: ['iOS'] })
isMotionRequestOutcomeAvailable(): Promise<boolean> { return; }
/**
* Requests and checks motion authorization for the application: there is no way to independently request only or check only, so both must be done in one operation.
*
* Learn more about this method [here](https://github.com/dpa99c/cordova-diagnostic-plugin#requestandcheckmotionauthorization)
*
* @return {Promise<any>}
*/
@Cordova({ platforms: ['iOS'] })
requestAndCheckMotionAuthorization(): Promise<any> { return; }
}
src/@ionic-native/plugins/dialogs/index.ts
+103
View File
@@ -0,0 +1,103 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface DialogsPromptCallback {
/**
* The index of the pressed button. (Number) Note that the index uses one-based indexing, so the value is 1, 2, 3, etc.
*/
buttonIndex: number;
/**
* The text entered in the prompt dialog box. (String)
*/
input1: string;
}
/**
* @name Dialogs
* @description
* This plugin gives you ability to access and customize the device native dialogs.
*
* Requires Cordova plugin: `cordova-plugin-dialogs`. For more info, please see the [Dialogs plugin docs](https://github.com/apache/cordova-plugin-dialogs).
*
* @usage
* ```typescript
* import { Dialogs } from '@ionic-native/dialogs';
*
* constructor(private dialogs: Dialogs) { }
*
* ...
*
* this.dialogs.alert('Hello world')
* .then(() => console.log('Dialog dismissed'))
* .catch(e => console.log('Error displaying dialog', e));
*
*
* ```
* @interfaces
* DialogsPromptCallback
*/
@Plugin({
pluginName: 'Dialogs',
plugin: 'cordova-plugin-dialogs',
pluginRef: 'navigator.notification',
repo: 'https://github.com/apache/cordova-plugin-dialogs.git'
})
@Injectable()
export class Dialogs {
/**
* Shows a custom alert or dialog box.
* @param {string} message Dialog message.
* @param {string} title Dialog title. (Optional, defaults to Alert)
* @param {string} buttonName Button name. (Optional, defaults to OK)
* @returns {Promise<any>} Returns a blank promise once the user has dismissed the alert.
*/
@Cordova({
successIndex: 1,
errorIndex: 4
})
alert(message: string, title?: string, buttonName?: string): Promise<any> { return; }
/**
* Displays a customizable confirmation dialog box.
* @param {string} message Dialog message.
* @param {string} title Dialog title. (Optional, defaults to Confirm)
* @param {Array<string>} buttonLabels Array of strings specifying button labels. (Optional, defaults to [OK,Cancel])
* @returns {Promise<number>} Returns a promise that resolves the button index that was clicked. Note that the index use one-based indexing.
*/
@Cordova({
successIndex: 1,
errorIndex: 4
})
confirm(message, title?: string, buttonLabels?: string[]): Promise<number> { return; }
/**
* Displays a native dialog box that is more customizable than the browser's prompt function.
* @param {string} message Dialog message.
* @param {string} title Dialog title. (Optional, defaults to Prompt)
* @param {Array<string>} buttonLabels Array of strings specifying button labels. (Optional, defaults to ["OK","Cancel"])
* @param {string} defaultText Default textbox input value. (Optional, Default: empty string)
* @returns {Promise<DialogsPromptCallback>} Returns a promise that resolves an object with the button index clicked and the text entered
*/
@Cordova({
successIndex: 1,
errorIndex: 5
})
prompt(message?: string, title?: string, buttonLabels?: string[], defaultText?: string): Promise<DialogsPromptCallback> { return; }
/**
* The device plays a beep sound.
* @param {numbers} times The number of times to repeat the beep.
*/
@Cordova({
sync: true
})
beep(times: number): void { }
}
src/@ionic-native/plugins/email-composer/index.ts
+135
View File
@@ -0,0 +1,135 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin, CordovaCheck } from '@ionic-native/core';
declare var cordova: any;
export interface EmailComposerOptions {
app?: string;
to?: string | Array<string>;
cc?: string | Array<string>;
bcc?: string | Array<string>;
attachments?: Array<any>;
subject?: string;
body?: string;
isHtml?: boolean;
}
/**
* @beta
* @name Email Composer
* @description
*
* Requires Cordova plugin: cordova-plugin-email-composer. For more info, please see the [Email Composer plugin docs](https://github.com/hypery2k/cordova-email-plugin).
*
* DISCLAIMER: This plugin is experiencing issues with the latest versions of Cordova. Use at your own risk. Functionality is not guaranteed. Please stay tuned for a more stable version.
* A good alternative to this plugin is the social sharing plugin.
*
* @usage
* ```typescript
* import { EmailComposer } from '@ionic-native/email-composer';
*
* constructor(private emailComposer: EmailComposer) { }
*
* ...
*
*
* this.emailComposer.isAvailable().then((available: boolean) =>{
* if(available) {
* //Now we know we can send
* }
* });
*
* let email = {
* to: 'max@mustermann.de',
* cc: 'erika@mustermann.de',
* bcc: ['john@doe.com', 'jane@doe.com'],
* attachments: [
* 'file://img/logo.png',
* 'res://icon.png',
* 'base64:icon.png//iVBORw0KGgoAAAANSUhEUg...',
* 'file://README.pdf'
* ],
* subject: 'Cordova Icons',
* body: 'How are you? Nice greetings from Leipzig',
* isHtml: true
* };
*
* // Send a text message using default options
* this.emailComposer.open(email);
*
* ```
* @interfaces
* EmailComposerOptions
*/
@Plugin({
pluginName: 'EmailComposer',
plugin: 'cordova-plugin-email',
pluginRef: 'cordova.plugins.email',
repo: 'https://github.com/hypery2k/cordova-email-plugin',
platforms: ['Android', 'iOS']
})
@Injectable()
export class EmailComposer {
/**
* Verifies if sending emails is supported on the device.
*
* @param app {string?} An optional app id or uri scheme.
* @returns {Promise<any>} Resolves if available, rejects if not available
*/
@CordovaCheck()
isAvailable(app?: string): Promise<any> {
return new Promise<boolean>((resolve, reject) => {
if (app) {
cordova.plugins.email.isAvailable(app, (isAvailable) => {
if (isAvailable) {
resolve();
} else {
reject();
}
});
} else {
cordova.plugins.email.isAvailable((isAvailable) => {
if (isAvailable) {
resolve();
} else {
reject();
}
});
}
});
}
/**
* Adds a new mail app alias.
*
* @param alias {string} The alias name
* @param packageName {string} The package name
*/
@Cordova()
addAlias(alias: string, packageName: string): void { }
/**
* Displays the email composer pre-filled with data.
*
* @param options {EmailComposerOptions} Email
* @param scope {any?} An optional scope for the promise
* @returns {Promise<any>} Resolves promise when the EmailComposer has been opened
*/
@Cordova({
successIndex: 1,
errorIndex: 3
})
open(options: EmailComposerOptions, scope?: any): Promise<any> { return; }
}
src/@ionic-native/plugins/estimote-beacons/index.ts
+515
View File
@@ -0,0 +1,515 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export interface EstimoteBeaconRegion {
state?: string;
major: number;
minor: number;
identifier?: string;
uuid: string;
}
/**
* @name Estimote Beacons
*
* @description
* This plugin enables communication between a phone and Estimote Beacons peripherals.
*
* @usage
* ```typescript
* import { EstimoteBeacons } from '@ionic-native/estimote-beacons';
*
* constructor(private eb: EstimoteBeacons) { }
*
* ...
*
* this.eb.requestAlwaysAuthorization();
*
* this.eb.enableAnalytics(true);
*
* ```
*
* @interfaces
* EstimoteBeaconRegion
*/
@Plugin({
pluginName: 'EstimoteBeacons',
plugin: 'cordova-plugin-estimote',
pluginRef: 'estimote.beacons',
repo: 'https://github.com/evothings/phonegap-estimotebeacons',
platforms: ['iOS', 'Android']
})
@Injectable()
export class EstimoteBeacons {
/** Proximity value */
ProximityUnknown = 0;
/** Proximity value */
ProximityImmediate = 1;
/** Proximity value */
ProximityNear = 2;
/** Proximity value */
ProximityFar = 3;
/** Beacon colour */
BeaconColorUnknown = 0;
/** Beacon colour */
BeaconColorMintCocktail = 1;
/** Beacon colour */
BeaconColorIcyMarshmallow = 2;
/** Beacon colour */
BeaconColorBlueberryPie = 3;
/**
* Beacon colour.
*/
BeaconColorSweetBeetroot = 4;
/** Beacon colour */
BeaconColorCandyFloss = 5;
/** Beacon colour */
BeaconColorLemonTart = 6;
/** Beacon colour */
BeaconColorVanillaJello = 7;
/** Beacon colour */
BeaconColorLiquoriceSwirl = 8;
/** Beacon colour */
BeaconColorWhite = 9;
/** Beacon colour */
BeaconColorTransparent = 10;
/** Region state */
RegionStateUnknown = 'unknown';
/** Region state */
RegionStateOutside = 'outside';
/** Region state */
RegionStateInside = 'inside';
/**
* Ask the user for permission to use location services
* while the app is in the foreground.
* You need to call this function or requestAlwaysAuthorization
* on iOS 8+.
* Does nothing on other platforms.
*
* @usage
* ```
* EstimoteBeacons.requestWhenInUseAuthorization().then(
* () => { console.log('on success'); },
* () => { console.log('on error'); }
* );
* ```
*
* @see {@link https://community.estimote.com/hc/en-us/articles/203393036-Estimote-SDK-and-iOS-8-Location-Services|Estimote SDK and iOS 8 Location Services}
* @returns {Promise<any>}
*/
@Cordova()
requestWhenInUseAuthorization(): Promise<any> { return; }
/**
* Ask the user for permission to use location services
* whenever the app is running.
* You need to call this function or requestWhenInUseAuthorization
* on iOS 8+.
* Does nothing on other platforms.
*
* @usage
* ```
* EstimoteBeacons.requestAlwaysAuthorization().then(
* () => { console.log('on success'); },
* () => { console.log('on error'); }
* );
* ```
*
* @see {@link https://community.estimote.com/hc/en-us/articles/203393036-Estimote-SDK-and-iOS-8-Location-Services|Estimote SDK and iOS 8 Location Services}
* @returns {Promise<any>}
*/
@Cordova()
requestAlwaysAuthorization(): Promise<any> { return; }
/**
* Get the current location authorization status.
* Implemented on iOS 8+.
* Does nothing on other platforms.
*
* @usage
* ```
* EstimoteBeacons.authorizationStatus().then(
* (result) => { console.log('Location authorization status: ' + result); },
* (errorMessage) => { console.log('Error: ' + errorMessage); }
* );
* ```
*
* @see {@link https://community.estimote.com/hc/en-us/articles/203393036-Estimote-SDK-and-iOS-8-Location-Services|Estimote SDK and iOS 8 Location Services}
* @returns {Promise<any>}
*/
@Cordova()
authorizationStatus(): Promise<any> { return; }
/**
* Start advertising as a beacon.
*
* @usage
* ```
* EstimoteBeacons.startAdvertisingAsBeacon('B9407F30-F5F8-466E-AFF9-25556B57FE6D', 1, 1, 'MyRegion')
* .then(() => { console.log('Beacon started'); });
* setTimeout(() => {
* EstimoteBeacons.stopAdvertisingAsBeacon().then((result) => { console.log('Beacon stopped'); });
* }, 5000);
* ```
* @param uuid {string} UUID string the beacon should advertise (mandatory).
* @param major {number} Major value to advertise (mandatory).
* @param minor {number} Minor value to advertise (mandatory).
* @param regionId {string} Identifier of the region used to advertise (mandatory).
* @returns {Promise<any>}
*/
@Cordova({
clearFunction: 'stopAdvertisingAsBeacon'
})
startAdvertisingAsBeacon(uuid: string, major: number, minor: number, regionId: string): Promise<any> { return; }
/**
* Stop advertising as a beacon.
*
* @usage
* ```
* EstimoteBeacons.startAdvertisingAsBeacon('B9407F30-F5F8-466E-AFF9-25556B57FE6D', 1, 1, 'MyRegion')
* .then(() => { console.log('Beacon started'); });
* setTimeout(() => {
* EstimoteBeacons.stopAdvertisingAsBeacon().then((result) => { console.log('Beacon stopped'); });
* }, 5000);
* ```
* @returns {Promise<any>}
*/
@Cordova()
stopAdvertisingAsBeacon(): Promise<any> { return; }
/**
* Enable analytics.
*
* @see {@link http://estimote.github.io/iOS-SDK/Classes/ESTConfig.html|Further details}
*
* @usage
* ```
* EstimoteBeacons.enableAnalytics(true).then(() => { console.log('Analytics enabled'); });
* ```
* @param enable {number} Boolean value to turn analytics on or off (mandatory).
* @returns {Promise<any>}
*/
@Cordova()
enableAnalytics(enable: boolean): Promise<any> { return; }
/**
* Test if analytics is enabled.
*
* @see {@link http://estimote.github.io/iOS-SDK/Classes/ESTConfig.html|Further details}
*
* @usage
* ```
* EstimoteBeacons.isAnalyticsEnabled().then((enabled) => { console.log('Analytics enabled: ' + enabled); });
* ```
* @returns {Promise<any>}
*/
@Cordova()
isAnalyticsEnabled(): Promise<any> { return; }
/**
* Test if App ID and App Token is set.
*
* @see {@link http://estimote.github.io/iOS-SDK/Classes/ESTConfig.html|Further details}
*
* @usage
* ```
* EstimoteBeacons.isAuthorized().then((isAuthorized) => { console.log('App ID and App Token is set: ' + isAuthorized); });
* ```
* @returns {Promise<any>}
*/
@Cordova()
isAuthorized(): Promise<any> { return; }
/**
* Set App ID and App Token.
*
* @see {@link http://estimote.github.io/iOS-SDK/Classes/ESTConfig.html|Further details}
*
* @usage
* ```
* EstimoteBeacons.setupAppIDAndAppToken('MyAppID', 'MyAppToken').then(() => { console.log('AppID and AppToken configured!'); });
* ```
* @param appID {string} The App ID (mandatory).
* @param appToken {string} The App Token (mandatory).
* @returns {Promise<any>}
*/
@Cordova()
setupAppIDAndAppToken(appID: string, appToken: string): Promise<any> { return; }
/**
* Start scanning for all nearby beacons using CoreBluetooth (no region object is used).
* Available on iOS.
*
* @usage
* ```
* EstimoteBeacons.startEstimoteBeaconDiscovery().subscribe(beacons => {
* console.log(JSON.stringify(beacons));
* });
* setTimeout(() => {
* EstimoteBeacons.stopEstimoteBeaconDiscovery().then(() => { console.log('scan stopped'); });
* }, 5000);
* ```
* @returns {Observable<any>} Returns an Observable that notifies of each beacon discovered.
*/
@Cordova({
observable: true,
clearFunction: 'stopEstimoteBeaconDiscovery'
})
startEstimoteBeaconDiscovery(): Observable<any> { return; }
/**
* Stop CoreBluetooth scan. Available on iOS.
*
* @usage
* ```
* EstimoteBeacons.startEstimoteBeaconDiscovery().subscribe(beacons => {
* console.log(JSON.stringify(beacons));
* });
* setTimeout(() => {
* EstimoteBeacons.stopEstimoteBeaconDiscovery().then(() => { console.log('scan stopped'); });
* }, 5000);
* ```
* @returns {Promise<any>}
*/
@Cordova()
stopEstimoteBeaconDiscovery(): Promise<any> { return; }
/**
* Start ranging beacons. Available on iOS and Android.
*
* @usage
* ```
* let region: EstimoteBeaconRegion = {} // Empty region matches all beacons.
* EstimoteBeacons.startRangingBeaconsInRegion(region).subscribe(info => {
* console.log(JSON.stringify(info));
* });
* setTimeout(() => {
* EstimoteBeacons.stopRangingBeaconsInRegion(region).then(() => { console.log('scan stopped'); });
* }, 5000);
* ```
* @param region {EstimoteBeaconRegion} Dictionary with region properties (mandatory).
* @returns {Observable<any>} Returns an Observable that notifies of each beacon discovered.
*/
@Cordova({
observable: true,
clearFunction: 'stopRangingBeaconsInRegion',
clearWithArgs: true
})
startRangingBeaconsInRegion(region: EstimoteBeaconRegion): Observable<any> { return; }
/**
* Stop ranging beacons. Available on iOS and Android.
*
* @usage
* ```
* let region: EstimoteBeaconRegion = {} // Empty region matches all beacons.
* EstimoteBeacons.startRangingBeaconsInRegion(region).subscribe(info => {
* console.log(JSON.stringify(info));
* });
* setTimeout(() => {
* EstimoteBeacons.stopRangingBeaconsInRegion(region).then(() => { console.log('scan stopped'); });
* }, 5000);
* ```
* @param region {EstimoteBeaconRegion} Dictionary with region properties (mandatory).
* @returns {Promise<any>}
*/
@Cordova()
stopRangingBeaconsInRegion(region: EstimoteBeaconRegion): Promise<any> { return; }
/**
* Start ranging secure beacons. Available on iOS.
* This function has the same parameters/behaviour as
* {@link EstimoteBeacons.startRangingBeaconsInRegion}.
* To use secure beacons set the App ID and App Token using
* {@link EstimoteBeacons.setupAppIDAndAppToken}.
* @returns {Observable<any>}
*/
@Cordova({
observable: true,
clearFunction: 'stopRangingSecureBeaconsInRegion',
clearWithArgs: true
})
startRangingSecureBeaconsInRegion(region: EstimoteBeaconRegion): Observable<any> { return; }
/**
* Stop ranging secure beacons. Available on iOS.
* This function has the same parameters/behaviour as
* {@link EstimoteBeacons.stopRangingBeaconsInRegion}.
* @returns {Promise<any>}
*/
@Cordova()
stopRangingSecureBeaconsInRegion(region: EstimoteBeaconRegion): Promise<any> { return; }
/**
* Start monitoring beacons. Available on iOS and Android.
*
* @usage
* ```
* let region: EstimoteBeaconRegion = {} // Empty region matches all beacons.
* EstimoteBeacons.startMonitoringForRegion(region).subscribe(state => {
* console.log('Region state: ' + JSON.stringify(state));
* });
* ```
* @param region {EstimoteBeaconRegion} Dictionary with region properties (mandatory).
* @param [notifyEntryStateOnDisplay=false] {boolean} Set to true to detect if you
* are inside a region when the user turns display on, see
* {@link https://developer.apple.com/library/prerelease/ios/documentation/CoreLocation/Reference/CLBeaconRegion_class/index.html#//apple_ref/occ/instp/CLBeaconRegion/notifyEntryStateOnDisplay|iOS documentation}
* for further details (optional, defaults to false, iOS only).
* @returns {Observable<any>} Returns an Observable that notifies of each region state discovered.
*/
@Cordova({
observable: true,
clearFunction: 'stopMonitoringForRegion',
clearWithArgs: true,
successIndex: 1,
errorIndex: 2
})
startMonitoringForRegion(region: EstimoteBeaconRegion, notifyEntryStateOnDisplay: boolean): Observable<any> { return; }
/**
* Stop monitoring beacons. Available on iOS and Android.
*
* @usage
* ```
* let region: EstimoteBeaconRegion = {} // Empty region matches all beacons.
* EstimoteBeacons.stopMonitoringForRegion(region).then(() => { console.log('monitoring is stopped'); });
* ```
* @param region {EstimoteBeaconRegion} Dictionary with region properties (mandatory).
* @returns {Promise<any>}
*/
@Cordova()
stopMonitoringForRegion(region: EstimoteBeaconRegion): Promise<any> { return; }
/**
* Start monitoring secure beacons. Available on iOS.
* This function has the same parameters/behaviour as
* EstimoteBeacons.startMonitoringForRegion.
* To use secure beacons set the App ID and App Token using
* {@link EstimoteBeacons.setupAppIDAndAppToken}.
* @see {@link EstimoteBeacons.startMonitoringForRegion}
* @param region {EstimoteBeaconRegion} Region
* @param notifyEntryStateOnDisplay {boolean}
* @returns {Observable<any>}
*/
@Cordova({
observable: true,
clearFunction: 'stopSecureMonitoringForRegion',
clearWithArgs: true,
successIndex: 1,
errorIndex: 2
})
startSecureMonitoringForRegion(region: EstimoteBeaconRegion, notifyEntryStateOnDisplay: boolean): Observable<any> { return; }
/**
* Stop monitoring secure beacons. Available on iOS.
* This function has the same parameters/behaviour as
* {@link EstimoteBeacons.stopMonitoringForRegion}.
* @param region {EstimoteBeaconRegion} Region
* @returns {Promise<any>}
*/
@Cordova()
stopSecureMonitoringForRegion(region: EstimoteBeaconRegion): Promise<any> { return; }
/**
* Connect to Estimote Beacon. Available on Android.
*
* @usage
* ```
* EstimoteBeacons.connectToBeacon(FF:0F:F0:00:F0:00);
* ```
* ```
* EstimoteBeacons.connectToBeacon({
* proximityUUID: '000000FF-F00F-0FF0-F000-000FF0F00000',
* major: 1,
* minor: 1
* });
* ```
* @param beacon {Beacon} Beacon to connect to.
* @returns {Promise<any>}
*/
@Cordova()
connectToBeacon(beacon: any): Promise<any> { return; }
/**
* Disconnect from connected Estimote Beacon. Available on Android.
*
* @usage
* ```
* EstimoteBeacons.disconnectConnectedBeacon();
* ```
* @returns {Promise<any>}
*/
@Cordova()
disconnectConnectedBeacon(): Promise<any> { return; }
/**
* Write proximity UUID to connected Estimote Beacon. Available on Android.
*
* @usage
* ```
* // Example that writes constant ESTIMOTE_PROXIMITY_UUID
* EstimoteBeacons.writeConnectedProximityUUID(ESTIMOTE_PROXIMITY_UUID);
*
* @param uuid {string} String to write as new UUID
* @returns {Promise<any>}
*/
@Cordova()
writeConnectedProximityUUID(uuid: any): Promise<any> { return; }
/**
* Write major to connected Estimote Beacon. Available on Android.
*
* @usage
* ```
* // Example that writes 1
* EstimoteBeacons.writeConnectedMajor(1);
*
* @param major {number} number to write as new major
* @returns {Promise<any>}
*/
@Cordova()
writeConnectedMajor(major: number): Promise<any> { return; }
/**
* Write minor to connected Estimote Beacon. Available on Android.
*
* @usage
* ```
* // Example that writes 1
* EstimoteBeacons.writeConnectedMinor(1);
*
* @param minor {number} number to write as new minor
* @returns {Promise<any>}
*/
@Cordova()
writeConnectedMinor(minor: number): Promise<any> { return; }
}
src/@ionic-native/plugins/facebook/index.ts
+282
View File
@@ -0,0 +1,282 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface FacebookLoginResponse {
status: string;
authResponse: {
session_key: boolean;
accessToken: string;
expiresIn: number;
sig: string;
secret: string;
userID: string;
};
}
/**
* @name Facebook
* @description
* Use the Facebook Connect plugin to obtain access to the native FB application on iOS and Android.
*
* Requires Cordova plugin: `cordova-plugin-facebook4`. For more info, please see the [Facebook Connect](https://github.com/jeduan/cordova-plugin-facebook4).
*
* #### Installation
*
* To use the FB plugin, you first have to create a new Facebook App inside of the Facebook developer portal at [https://developers.facebook.com/apps](https://developers.facebook.com/apps).
*
* [![fb-getstarted-1](/img/docs/native/Facebook/1.png)](https://developers.facebook.com/apps/)
*
* Retrieve the `App ID` and `App Name`.
*
* [![fb-getstarted-2](/img/docs/native/Facebook/2.png)](https://developers.facebook.com/apps/)
*
* Then type in the following command in your Terminal, where APP_ID and APP_NAME are the values from the Facebook Developer portal.
*
* ```bash
* ionic plugin add cordova-plugin-facebook4 --save --variable APP_ID="123456789" --variable APP_NAME="myApplication"
* ```
*
* After, you'll need to add the native platforms you'll be using to your app in the Facebook Developer portal under your app's Settings:
*
* [![fb-getstarted-3](/img/docs/native/Facebook/3.png)](https://developers.facebook.com/apps/)
*
* Click `'Add Platform'`.
*
* [![fb-getstarted-4](/img/docs/native/Facebook/4.png)](https://developers.facebook.com/apps/)
*
* At this point you'll need to open your project's [`config.xml`](https://cordova.apache.org/docs/en/latest/config_ref/index.html) file, found in the root directory of your project.
*
* Take note of the `id` for the next step:
* ```
* <widget id="com.mycompany.testapp" version="0.0.1" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
* ```
*
* You can also edit the `id` to whatever you'd like it to be.
*
* #### iOS Install
* Under 'Bundle ID', add the `id` from your `config.xml` file:
*
* [![fb-getstarted-5](/img/docs/native/Facebook/5.png)](https://developers.facebook.com/apps/)
*
*
* #### Android Install
* Under 'Google Play Package Name', add the `id` from your `config.xml` file:
*
* [![fb-getstarted-6](/img/docs/native/Facebook/6.png)](https://developers.facebook.com/apps/)
*
*
* And that's it! You can now make calls to Facebook using the plugin.
*
* ## Events
*
* App events allow you to understand the makeup of users engaging with your app, measure the performance of your Facebook mobile app ads, and reach specific sets of your users with Facebook mobile app ads.
*
* - [iOS] [https://developers.facebook.com/docs/ios/app-events](https://developers.facebook.com/docs/ios/app-events)
* - [Android] [https://developers.facebook.com/docs/android/app-events](https://developers.facebook.com/docs/android/app-events)
* - [JS] Does not have an Events API, so the plugin functions are empty and will return an automatic success
*
* Activation events are automatically tracked for you in the plugin.
*
* Events are listed on the [insights page](https://www.facebook.com/insights/).
*
* For tracking events, see `logEvent` and `logPurchase`.
*
* @usage
* ```typescript
* import { Facebook, FacebookLoginResponse } from '@ionic-native/facebook';
*
* constructor(private fb: Facebook) { }
*
* ...
*
* this.fb.login(['public_profile', 'user_friends', 'email'])
* .then((res: FacebookLoginResponse) => console.log('Logged into Facebook!', res))
* .catch(e => console.log('Error logging into Facebook', e));
*
*
* ```
*
*/
@Plugin({
pluginName: 'Facebook',
plugin: 'cordova-plugin-facebook4',
pluginRef: 'facebookConnectPlugin',
repo: 'https://github.com/jeduan/cordova-plugin-facebook4',
install: 'ionic plugin add cordova-plugin-facebook4 --variable APP_ID="123456789" --variable APP_NAME="myApplication"',
installVariables: ['APP_ID', 'APP_NAME']
})
@Injectable()
export class Facebook {
/**
* Browser wrapper
* @param {number} appId Your Facebook AppID from their dashboard
* @param {string} version The version of API you may want to use. Optional
* @returns {Promise<any>}
*/
@Cordova()
browserInit(appId: number, version?: string): Promise<any> {
return;
}
/**
* Login to Facebook to authenticate this app.
*
* ```typescript
* {
* status: "connected",
* authResponse: {
* session_key: true,
* accessToken: "kgkh3g42kh4g23kh4g2kh34g2kg4k2h4gkh3g4k2h4gk23h4gk2h34gk234gk2h34AndSoOn",
* expiresIn: 5183979,
* sig: "...",
* secret: "...",
* userID: "634565435"
* }
* }
* ```
*
* @param {string[]} permissions List of [permissions](https://developers.facebook.com/docs/facebook-login/permissions) this app has upon logging in.
* @returns {Promise<FacebookLoginResponse>} Returns a Promise that resolves with a status object if login succeeds, and rejects if login fails.
*/
@Cordova()
login(permissions: string[]): Promise<FacebookLoginResponse> { return; }
/**
* Logout of Facebook.
*
* For more info see the [Facebook docs](https://developers.facebook.com/docs/reference/javascript/FB.logout)
* @returns {Promise<any>} Returns a Promise that resolves on a successful logout, and rejects if logout fails.
*/
@Cordova()
logout(): Promise<any> { return; }
/**
* Determine if a user is logged in to Facebook and has authenticated your app. There are three possible states for a user:
*
* 1) the user is logged into Facebook and has authenticated your application (connected)
* 2) the user is logged into Facebook but has not authenticated your application (not_authorized)
* 3) the user is either not logged into Facebook or explicitly logged out of your application so it doesn't attempt to connect to Facebook and thus, we don't know if they've authenticated your application or not (unknown)
*
* Resolves with a response like:
*
* ```
* {
* authResponse: {
* userID: "12345678912345",
* accessToken: "kgkh3g42kh4g23kh4g2kh34g2kg4k2h4gkh3g4k2h4gk23h4gk2h34gk234gk2h34AndSoOn",
* session_Key: true,
* expiresIn: "5183738",
* sig: "..."
* },
* status: "connected"
* }
* ```
*
* For more information see the [Facebook docs](https://developers.facebook.com/docs/reference/javascript/FB.getLoginStatus)
*
* @returns {Promise<any>} Returns a Promise that resolves with a status, or rejects with an error
*/
@Cordova()
getLoginStatus(): Promise<any> { return; }
/**
* Get a Facebook access token for using Facebook services.
*
* @returns {Promise<string>} Returns a Promise that resolves with an access token, or rejects with an error
*/
@Cordova()
getAccessToken(): Promise<string> { return; }
/**
* Show one of various Facebook dialogs. Example of options for a Share dialog:
*
* ```
* {
* method: "share",
* href: "http://example.com",
* caption: "Such caption, very feed.",
* description: "Much description",
* picture: 'http://example.com/image.png'
* }
* ```
*
* For more options see the [Cordova plugin docs](https://github.com/jeduan/cordova-plugin-facebook4#show-a-dialog) and the [Facebook docs](https://developers.facebook.com/docs/javascript/reference/FB.ui)
* @param {Object} options The dialog options
* @returns {Promise<any>} Returns a Promise that resolves with success data, or rejects with an error
*/
@Cordova()
showDialog(options: any): Promise<any> { return; }
/**
* Make a call to Facebook Graph API. Can take additional permissions beyond those granted on login.
*
* For more information see:
*
* Calling the Graph API - https://developers.facebook.com/docs/javascript/reference/FB.api
* Graph Explorer - https://developers.facebook.com/tools/explorer
* Graph API - https://developers.facebook.com/docs/graph-api
*
* @param {string} requestPath Graph API endpoint you want to call
* @param {string[]} permissions List of [permissions](https://developers.facebook.com/docs/facebook-login/permissions) for this request.
* @returns {Promise<any>} Returns a Promise that resolves with the result of the request, or rejects with an error
*/
@Cordova()
api(requestPath: string, permissions: string[]): Promise<any> { return; }
/**
* Log an event. For more information see the Events section above.
*
* @param {string} name Name of the event
* @param {Object} [params] An object containing extra data to log with the event
* @param {number} [valueToSum] any value to be added to added to a sum on each event
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 3,
errorIndex: 4
})
logEvent(name: string, params?: Object, valueToSum?: number): Promise<any> { return; }
/**
* Log a purchase. For more information see the Events section above.
*
* @param {number} value Value of the purchase.
* @param {string} currency The currency, as an [ISO 4217 currency code](http://en.wikipedia.org/wiki/ISO_4217)
* @returns {Promise<any>}
*/
@Cordova()
logPurchase(value: number, currency: string): Promise<any> { return; }
/**
* Open App Invite dialog. Does not require login.
*
* For more information see:
*
* the App Invites Overview - https://developers.facebook.com/docs/app-invites/overview
* the App Links docs - https://developers.facebook.com/docs/applinks
*
*
* @param {Object} options An object containing an [App Link](https://developers.facebook.com/docs/applinks) URL to your app and an optional image URL.
* url: [App Link](https://developers.facebook.com/docs/applinks) to your app
* picture: image to be displayed in the App Invite dialog
*
* @returns {Promise<any>} Returns a Promise that resolves with the result data, or rejects with an error
*/
@Cordova()
appInvite(options: {
url: string,
picture: string
}): Promise<any> { return; }
}
src/@ionic-native/plugins/file-chooser/index.ts
+41
View File
@@ -0,0 +1,41 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name File Chooser
* @description
*
* Opens the file picker on Android for the user to select a file, returns a file URI.
*
* @usage
* ```
* import { FileChooser } from '@ionic-native/file-chooser';
*
* constructor(private fileChooser: FileChooser) { }
*
* ...
*
* this.fileChooser.open()
* .then(uri => console.log(uri))
* .catch(e => console.log(e));
*
* ```
*/
@Plugin({
pluginName: 'FileChooser',
plugin: 'http://github.com/don/cordova-filechooser.git',
pluginRef: 'fileChooser',
repo: 'https://github.com/don/cordova-filechooser',
platforms: ['Android']
})
@Injectable()
export class FileChooser {
/**
* Open a file
* @returns {Promise<string>}
*/
@Cordova()
open(): Promise<string> { return; }
}
src/@ionic-native/plugins/file-opener/index.ts
+69
View File
@@ -0,0 +1,69 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name File Opener
* @description
* This plugin will open a file on your device file system with its default application.
*
* @usage
* ```
* import { FileOpener } from '@ionic-native/file-opener';
*
* constructor(private fileOpener: FileOpener) { }
*
* ...
*
* this.fileOpener.open('path/to/file.pdf', 'application/pdf')
* .then(() => console.log('File is opened'))
* .catch(e => console.log('Error openening file', e));
*
* ```
*/
@Plugin({
pluginName: 'FileOpener',
plugin: 'cordova-plugin-file-opener2',
pluginRef: 'cordova.plugins.fileOpener2',
repo: 'https://github.com/pwlin/cordova-plugin-file-opener2'
})
@Injectable()
export class FileOpener {
/**
* Open an file
* @param filePath {string} File Path
* @param fileMIMEType {string} File MIME Type
* @returns {Promise<any>}
*/
@Cordova({
callbackStyle: 'object',
successName: 'success',
errorName: 'error'
})
open(filePath: string, fileMIMEType: string): Promise<any> {return; }
/**
* Uninstalls a package
* @param packageId {string} Package ID
* @returns {Promise<any>}
*/
@Cordova({
callbackStyle: 'object',
successName: 'success',
errorName: 'error'
})
uninstall(packageId: string): Promise<any> {return; }
/**
* Check if an app is already installed
* @param packageId {string} Package ID
* @returns {Promise<any>}
*/
@Cordova({
callbackStyle: 'object',
successName: 'success',
errorName: 'error'
})
appIsInstalled(packageId: string): Promise<any> {return; }
}
src/@ionic-native/plugins/file-path/index.ts
+44
View File
@@ -0,0 +1,44 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
declare var window: any;
/**
* @name File Path
* @description
*
* This plugin allows you to resolve the native filesystem path for Android content URIs and is based on code in the aFileChooser library.
*
* @usage
* ```
* import { FilePath } from '@ionic-native/file-path';
*
* constructor(private filePath: FilePath) { }
*
* ...
*
* this.filePath.resolveNativePath(path)
* .then(filePath => console.log(filePath);
* .catch(err => console.log(err);
*
* ```
*/
@Plugin({
pluginName: 'FilePath',
plugin: 'cordova-plugin-filepath',
pluginRef: 'window.FilePath',
repo: 'https://github.com/hiddentao/cordova-plugin-filepath',
platforms: ['Android']
})
@Injectable()
export class FilePath {
/**
* Resolve native path for given content URL/path.
* @param {String} path Content URL/path.
* @returns {Promise<string>}
*/
@Cordova()
resolveNativePath(path: string): Promise<string> {return; }
}
src/@ionic-native/plugins/file/index.ts
+1271
View File
File diff suppressed because it is too large Load Diff
src/@ionic-native/plugins/fingerprint-aio/index.ts
+74
View File
@@ -0,0 +1,74 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
export interface FingerprintOptions {
/**
* Key for platform keychain
*/
clientId: string;
/**
* Secret password. Only for android
*/
clientSecret?: string;
/**
* Disable 'use backup' option. Only for android (optional)
*/
disableBackup?: boolean;
}
/**
* @beta
* @name FingerprintAIO
* @description
* Use simple fingerprint authentication on Android and iOS.
* Requires Cordova plugin: cordova-plugin-fingerprint-aio. For more info about plugin, vist: https://github.com/NiklasMerz/cordova-plugin-fingerprint-aio
*
* @usage
* ```typescript
* import { FingerprintAIO } from '@ionic-native/fingerprint-aio';
*
* constructor(private faio: FingerpirntAIO) { }
*
* ...
*
* this.faio.show({
* clientId: "Fingerprint-Demo",
* clientSecret: "password", //Only necessary for Android
* disableBackup:true //Only for Android(optional)
* })
* .then((result: any) => console.log(any))
* .catch((error: any) => console.log(error));
*
* ```
* @interfaces
* FingerprintOptions
*/
@Plugin({
pluginName: 'FingerprintAIO',
plugin: 'cordova-plugin-fingerprint-aio',
pluginRef: 'Fingerprint',
repo: 'https://github.com/NiklasMerz/cordova-plugin-fingerprint-aio',
platforms: ['Android', 'iOS']
})
@Injectable()
export class FingerprintAIO {
/**
* Check if fingerprint authentication is available
* @return {Promise<any>} Returns a promise with result
*/
@Cordova()
isAvailable(): Promise<any> { return; }
/**
* Show authentication dialogue
* @param options {FingerprintOptions} options for platform specific fingerprint API
* @return {Promise<any>} Returns a promise that resolves when authentication was successfull
*/
@Cordova()
show(options: FingerprintOptions): Promise<any> { return; }
}
src/@ionic-native/plugins/firebase/index.ts
+224
View File
@@ -0,0 +1,224 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
/**
* @name Firebase
* @description
* This plugin brings push notifications, analytics, event tracking, crash reporting and more from Google Firebase to your Cordova project! Android and iOS supported (including iOS 10).
*
* @usage
* ```
* import { Firebase } from '@ionic-native/firebase';
*
* constructor(private firebase: Firebase) { }
*
* ...
*
* this.firebase.getToken()
* .then(token => console.log(`The token is ${token}`)) // save the token server-side and use it to push notifications to this device
* .catch(error => console.error('Error getting token', error));
*
* this.firebase.onTokenRefresh()
* .subscribe((token: string) => console.log(`Got a new token ${token}`));
*
* ```
*/
@Plugin({
pluginName: 'Firebase',
plugin: 'cordova-plugin-firebase',
pluginRef: 'FirebasePlugin',
repo: 'https://github.com/arnesson/cordova-plugin-firebase',
platforms: ['Android', 'iOS']
})
@Injectable()
export class Firebase {
/**
* Get the device token
* @return {Promise<any>}
*/
@Cordova()
getToken(): Promise<any> { return; }
/**
* Get notified when a token is refreshed
* @return {Observable<any>}
*/
@Cordova({
observable: true
})
onTokenRefresh(): Observable<any> { return; }
/**
* Get notified when the user opens a notification
* @return {Observable<any>}
*/
@Cordova({
observable: true
})
onNotificationOpen(): Observable<any> { return; }
/**
* Grant permission to recieve push notifications
* @return {Promise<any>}
*/
@Cordova({
platforms: ['iOS']
})
grantPermission(): Promise<any> { return; }
/**
* Check permission to recieve push notifications
* @return {Promise<any>}
*/
@Cordova({
platforms: ['iOS']
})
hasPermission(): Promise<any> { return; }
/**
* Set icon badge number. Set to 0 to clear the badge.
* @param badgeNumber {number}
* @return {Promise<any>}
*/
@Cordova()
setBadgeNumber(badgeNumber: number): Promise<any> { return; }
/**
* Get icon badge number
* @return {Promise<any>}
*/
@Cordova()
getBadgeNumber(): Promise<any> { return; }
/**
* Subscribe to a topic
* @param topic {string}
* @return {Promise<any>}
*/
@Cordova()
subscribe(topic: string): Promise<any> { return; }
/**
* Unsubscribe from a topic
* @param topic {string}
* @return {Promise<any>}
*/
@Cordova()
unsubscribe(topic: string): Promise<any> { return; }
/**
* Log an event using Analytics
* @param type {string}
* @param data {Object}
* @return {Promise<any>}
*/
@Cordova()
logEvent(type: string, data: any): Promise<any> { return; }
/**
* Set the name of the current screen in Analytics
* @param name {string} Screen name
* @return {Promise<any>}
*/
@Cordova()
setScreenName(name: string): Promise<any> { return; }
/**
* Set a user id for use in Analytics
* @param userId {string}
* @return {Promise<any>}
*/
@Cordova()
setUserId(userId: string): Promise<any> { return; }
/**
* Set a user property for use in Analytics
* @param name {string}
* @param value {string}
* @return {Promise<any>}
*/
@Cordova()
setUserProperty(name: string, value: string): Promise<any> { return; }
/**
* Fetch Remote Config parameter values for your app
* @param cacheExpirationSeconds
* @return {Promise<any>}
*/
@Cordova({
platforms: ['Android'],
successIndex: 1,
errorIndex: 2
})
fetch(cacheExpirationSeconds?: number): Promise<any> { return; }
/**
* Activate the Remote Config fetched config
* @return {Promise<any>}
*/
@Cordova({
platforms: ['Android']
})
activateFetched(): Promise<any> { return; }
/**
* Retrieve a Remote Config value
* @param key {string}
* @param namespace {string}
* @return {Promise<any>}
*/
@Cordova({
platforms: ['Android'],
successIndex: 2,
errorIndex: 3
})
getValue(key: string, namespace?: string): Promise<any> { return; }
/**
* Retrieve a Remote Config byte array
* @param key {string}
* @param namespace {string}
* @return {Promise<any>}
*/
@Cordova({
platforms: ['Android'],
successIndex: 2,
errorIndex: 3
})
getByteArray(key: string, namespace?: string): Promise<any> { return; }
/**
* Get the current state of the FirebaseRemoteConfig singleton object
* @return {Promise<any>}
*/
@Cordova({
platforms: ['Android']
})
getInfo(): Promise<any> { return; }
/**
* Change the settings for the FirebaseRemoteConfig object's operations
* @param settings {Object}
* @return {Promise<any>}
*/
@Cordova({
platforms: ['Android']
})
setConfigSettings(settings: any): Promise<any> { return; }
/**
* Set defaults in the Remote Config
* @param defaults {Object}
* @param namespace {string}
* @return {Promise<any>}
*/
@Cordova({
platforms: ['Android'],
successIndex: 2,
errorIndex: 3
})
setDefaults(defaults: any, namespace: string): Promise<any> { return; }
}
src/@ionic-native/plugins/flashlight/index.ts
+70
View File
@@ -0,0 +1,70 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Flashlight
* @description This plugin allows you to switch the flashlight / torch of the device on and off.
*
* Requires Cordova plugin: `cordova-plugin-flashlight`. For more info, please see the [Flashlight plugin docs](https://github.com/EddyVerbruggen/Flashlight-PhoneGap-Plugin).
*
* @usage
* ```typescript
* import { Flashlight } from '@ionic-native/flashlight';
*
* constructor(private flashlight: FlashLight) { }
*
* ...
*
* this.flashlight.switchOn();
*
*
* ```
*/
@Plugin({
pluginName: 'Flashlight',
plugin: 'cordova-plugin-flashlight',
pluginRef: 'window.plugins.flashlight',
repo: 'https://github.com/EddyVerbruggen/Flashlight-PhoneGap-Plugin.git'
})
@Injectable()
export class Flashlight {
/**
* Checks if the flashlight is available
* @returns {Promise<boolean>} Returns a promise that resolves with a boolean stating if the flashlight is available.
*/
@Cordova()
available(): Promise<boolean> { return; }
/**
* Switches the flashlight on
* @returns {Promise<boolean>}
*/
@Cordova()
switchOn(): Promise<boolean> { return; }
/**
* Switches the flashlight off
* @returns {Promise<boolean>}
*/
@Cordova()
switchOff(): Promise<boolean> { return; }
/**
* Toggles the flashlight
* @returns {Promise<any>}
*/
@Cordova()
toggle(): Promise<any> { return; }
/**
* Checks if the flashlight is turned on.
* @returns {boolean}
*/
@Cordova({
sync: true
})
isSwitchedOn(): boolean { return; }
}
src/@ionic-native/plugins/geofence/index.ts
+171
View File
@@ -0,0 +1,171 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin, CordovaFunctionOverride } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
declare var window: any;
/**
* @name Geofence
* @description Monitors circular geofences around latitude/longitude coordinates, and sends a notification to the user when the boundary of a geofence is crossed. Notifications can be sent when the user enters and/or exits a geofence.
* Geofences persist after device reboot. Geofences will be monitored even when the app is not running.
* @usage
* ```
* import { Geofence } from '@ionic-native/geofence';
*
* ...
*
* constructor(private geofence: Geofence) {
* // initialize the plugin
* geofence.initialize().then(
* // resolved promise does not return a value
* () => console.log('Geofence Plugin Ready'),
* (err) => console.log(err)
* )
* }
*
* ...
*
* private addGeofence() {
* //options describing geofence
* let fence = {
* id: "69ca1b88-6fbe-4e80-a4d4-ff4d3748acdb", //any unique ID
* latitude: 37.285951, //center of geofence radius
* longitude: -121.936650,
* radius: 100, //radius to edge of geofence
* transitionType: 3, //see 'Transition Types' below
* notification: { //notification settings
* id: 1, //any unique ID
* title: "You crossed a fence", //notification title
* text: "You just arrived to Gliwice city center.", //notification body
* openAppOnClick: true //open app when notification is tapped
* }
* }
*
* this.geofence.addOrUpdate(fence).then(
* () => console.log('Geofence added'),
* (err) => console.log('Geofence failed to add')
* );
* }
*
* ```
* ### Transition Types ###
* Transition type specifies whether the geofence should trigger when the user enters and/or leaves the geofence.
*
* #### Supported values ####
* - 1: Enter
* - 2: Leave
* - 3: Both
*
* ### Defining a Geofence ###
* Geofences are defined by an object that is passed to `addOrUpdate()`. Object properties are:
* - id: Any unique ID for the geofence. This ID is used to remove and update a geofence
* - latitude: Latitude coordinate of the center of the geofence radius
* - longitude: Latitude coordinate of the center of the geofence radius
* - radius: Radius from the center to the edge of the geofence
* - transitionType: Type of geofence transition to monitor for. See 'Transition Types' above
* - notification: Object. Options for defining the notification sent when a geofence is crossed
* - id: Any unique ID
* - title: Notification title
* - text: Notification body
* - openAppOnClick: Boolean. Whether to open the app when the notification is tapped by the user
*
* ### Troubleshooting ###
* #### I get compile errors when I run `ionic build ios` or `ionic run ios`. ####
* This could be caused by the Cordova project directory in `/platforms/ios` not being named correctly.
* Try running `ionic platform rm <platform>` then run `ionic platform add <platform>` to recreate the
* platform directories.
*/
@Plugin({
pluginName: 'Geofence',
plugin: 'cordova-plugin-geofence',
pluginRef: 'geofence',
repo: 'https://github.com/cowbell/cordova-plugin-geofence/',
platforms: ['Android', 'iOS', 'Windows Phone 8', 'Windows Phone']
})
@Injectable()
export class Geofence {
public TransitionType = {
ENTER: 1,
EXIT: 2,
BOTH: 3
};
/**
* Subscribe to get notified when a transition is received
* @return {Observable<any>}
*/
@CordovaFunctionOverride()
onTrasitionReceived(): Observable<any> { return; };
/**
* Initializes the plugin. User will be prompted to allow the app to use location and notifications.
*
* @returns {Promise<void>}
*/
@Cordova()
initialize(): Promise<void> { return; };
/**
* Adds a new geofence or array of geofences. For geofence object, see above.
*
* @returns {Promise<void>}
*/
@Cordova()
addOrUpdate(geofences: Object | Array<Object>): Promise<void> { return; };
/**
* Removes a geofence or array of geofences. `geofenceID` corresponds to one or more IDs specified when the
* geofence was created.
*
* @returns {Promise<void>}
*/
@Cordova()
remove(geofenceId: string | Array<string>): Promise<void> { return; };
/**
* Removes all geofences.
*
* @returns {Promise<void>}
*/
@Cordova()
removeAll(): Promise<void> { return; };
/**
* Returns an array of geofences currently being monitored.
*
* @returns {Promise<Array<string>>}
*/
@Cordova()
getWatched(): Promise<string> { return; };
/**
* Called when a geofence is crossed in the direction specified by `TransitType`.
*
* @returns {Observable<any>}
*/
onTransitionReceived(): Observable<any> {
return new Observable<any>((observer) => {
window && window.geofence && (window.geofence.onTransitionReceived = observer.next.bind(observer));
return () => window.geofence.onTransitionReceived = () => {};
});
}
/**
* Called when the user clicks a geofence notification. iOS and Android only.
*
* @returns {Observable<any>}
*/
onNotificationClicked(): Observable<any> {
return new Observable<any>((observer) => {
window && window.geofence && (window.geofence.onNotificationClicked = observer.next.bind(observer));
return () => window.geofence.onNotificationClicked = () => {};
});
}
}
src/@ionic-native/plugins/geolocation/index.ts
+193
View File
@@ -0,0 +1,193 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
declare var navigator: any;
export interface Coordinates {
/**
* a double representing the position's latitude in decimal degrees.
*/
latitude: number;
/**
* A double representing the position's longitude in decimal degrees.
*/
longitude: number;
/**
* A double representing the accuracy of the latitude and longitude properties,
* expressed in meters.
*/
accuracy: number;
/**
* A double representing the position's altitude in metres, relative to sea
* level. This value can be null if the implementation cannot provide the data.
*/
altitude: number;
/**
* A double representing the accuracy of the altitude expressed in meters.
* This value can be null.
*/
altitudeAccuracy: number;
/**
* A double representing the direction in which the device is traveling. This
* value, specified in degrees, indicates how far off from heading true north
* the device is. 0 degrees represents true north, and the direction is
* determined clockwise (which means that east is 90 degrees and west is 270
* degrees). If speed is 0, heading is NaN. If the device is unable to provide
* heading information, this value is null.
*/
heading: number;
/**
* A double representing the velocity of the device in meters per second.
* This value can be null.
*/
speed: number;
}
export interface Geoposition {
/**
* A Coordinates object defining the current location
*/
coords: Coordinates;
/**
* A timestamp representing the time at which the location was retrieved.
*/
timestamp: number;
}
export interface PositionError {
/**
* A code that indicates the error that occurred
*/
code: number;
/**
* A message that can describe the error that occurred
*/
message: string;
}
export interface GeolocationOptions {
/**
* Is a positive long value indicating the maximum age in milliseconds of a
* possible cached position that is acceptable to return. If set to 0, it
* means that the device cannot use a cached position and must attempt to
* retrieve the real current position. If set to Infinity the device must
* return a cached position regardless of its age. Default: 0.
*/
maximumAge?: number;
/**
* Is a positive long value representing the maximum length of time
* (in milliseconds) the device is allowed to take in order to return a
* position. The default value is Infinity, meaning that getCurrentPosition()
* won't return until the position is available.
*/
timeout?: number;
/**
* Indicates the application would like to receive the best possible results.
* If true and if the device is able to provide a more accurate position, it
* will do so. Note that this can result in slower response times or increased
* power consumption (with a GPS chip on a mobile device for example). On the
* other hand, if false, the device can take the liberty to save resources by
* responding more quickly and/or using less power. Default: false.
* @type {boolean}
*/
enableHighAccuracy?: boolean;
}
/**
* @name Geolocation
* @description
* This plugin provides information about the device's location, such as latitude and longitude. Common sources of location information include Global Positioning System (GPS) and location inferred from network signals such as IP address, RFID, WiFi and Bluetooth MAC addresses, and GSM/CDMA cell IDs.
*
* This API is based on the W3C Geolocation API Specification, and only executes on devices that don't already provide an implementation.
*
* @usage
*
* ```typescript
* import { Geolocation } from '@ionic-native/geolocation';
*
*
* Geolocation.getCurrentPosition().then((resp) => {
* // resp.coords.latitude
* // resp.coords.longitude
* }).catch((error) => {
* console.log('Error getting location', error);
* });
*
* let watch = Geolocation.watchPosition();
* watch.subscribe((data) => {
* // data can be a set of coordinates, or an error (if an error occurred).
* // data.coords.latitude
* // data.coords.longitude
* });
* ```
* @interfaces
* Coordinates
* Geoposition
* PositionError
* GeolocationOptions
*/
@Plugin({
pluginName: 'Geolocation',
plugin: 'cordova-plugin-geolocation',
pluginRef: 'navigator.geolocation',
repo: 'https://github.com/apache/cordova-plugin-geolocation'
})
@Injectable()
export class Geolocation {
/**
* Get the device's current position.
*
* @param {GeolocationOptions} options The [geolocation options](https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions).
* @returns {Promise<Geoposition>} Returns a Promise that resolves with the [position](https://developer.mozilla.org/en-US/docs/Web/API/Position) of the device, or rejects with an error.
*/
@Cordova({
callbackOrder: 'reverse'
})
getCurrentPosition(options?: GeolocationOptions): Promise<Geoposition> { return; }
/**
* Watch the current device's position. Clear the watch by unsubscribing from
* Observable changes.
*
* ```typescript
* var subscription = Geolocation.watchPosition()
* .filter((p) => p.coords !== undefined) //Filter Out Errors
* .subscribe(position => {
* console.log(position.coords.longitude + ' ' + position.coords.latitude);
* });
*
* // To stop notifications
* subscription.unsubscribe();
* ```
*
* @param {GeolocationOptions} options The [geolocation options](https://developer.mozilla.org/en-US/docs/Web/API/PositionOptions).
* @returns {Observable<Geoposition>} Returns an Observable that notifies with the [position](https://developer.mozilla.org/en-US/docs/Web/API/Position) of the device, or errors.
*/
watchPosition(options?: GeolocationOptions): Observable<Geoposition> {
return new Observable<Geoposition>(
(observer: any) => {
let watchId = navigator.geolocation.watchPosition(observer.next.bind(observer), observer.next.bind(observer), options);
return () => navigator.geolocation.clearWatch(watchId);
}
);
}
}
src/@ionic-native/plugins/globalization/index.ts
+148
View File
@@ -0,0 +1,148 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Globalization
* @description
* @usage
* ```typescript
* import { Globalization } from '@ionic-native/globalization';
*
* constructor(private globalization: Globalization) { }
*
*
* ...
*
*
* this.globalization.getPreferredLanguage()
* .then(res => console.log(res))
* .catch(e => console.log(e));
*
*
* ```
*/
@Plugin({
pluginName: 'Globalization',
plugin: 'cordova-plugin-globalization',
pluginRef: 'navigator.globalization',
repo: 'https://github.com/apache/cordova-plugin-globalization',
platforms: ['Amazon Fire OS', 'Android', 'BlackBerry 10', 'Firefox OS', 'iOS', 'Windows Phone 8', 'Widnows', 'Browser']
})
@Injectable()
export class Globalization {
/**
* Returns the BCP-47 compliant language identifier tag to the successCallback with a properties object as a parameter. That object should have a value property with a String value.
* @returns {Promise<{value: string}>}
*/
@Cordova()
getPreferredLanguage(): Promise<{ value: string }> { return; }
/**
* Returns the BCP 47 compliant locale identifier string to the successCallback with a properties object as a parameter.
* @returns {Promise<{value: string}>}
*/
@Cordova()
getLocaleName(): Promise<{ value: string }> { return; }
/**
* Converts date to string
* @param {Date} date Date you wish to convert
* @param options Options for the converted date. Length, selector.
* @returns {Promise<{value: string}>} Returns a promise when the date has been converted.
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
dateToString(date: Date, options: { formatLength: string, selector: string }): Promise<{ value: string }> { return; }
/**
* Parses a date formatted as a string, according to the client's user preferences and calendar using the time zone of the client, and returns the corresponding date object.
* @param {string} dateString Date as a string to be converted
* @param options Options for the converted date. Length, selector.
* @returns {Promise<{ year: number, month: number, day: number, hour: number, minute: number, second: number, millisecond: number }>} Returns a promise when the date has been converted.
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
stringToDate(dateString: string, options: { formatLength: string, selector: string }): Promise<{ year: number, month: number, day: number, hour: number, minute: number, second: number, millisecond: number }> { return; }
/**
* Returns a pattern string to format and parse dates according to the client's user preferences.
* @param options Object with the format length and selector
* @returns {Promise<{pattern: string}>} Returns a promise.
*/
@Cordova({
callbackOrder: 'reverse'
})
getDatePattern(options: { formatLength: string, selector: string }): Promise<{ pattern: string }> { return; }
/**
* Returns an array of the names of the months or days of the week, depending on the client's user preferences and calendar.
* @param options Object with type (narrow or wide) and item (month or days).
* @returns {Promise<{value: Array<string>}>} Returns a promise.
*/
@Cordova({
callbackOrder: 'reverse'
})
getDateNames(options: { type: string, item: string }): Promise<{ value: Array<string> }> { return; }
/**
* Indicates whether daylight savings time is in effect for a given date using the client's time zone and calendar.
* @param {data} date Date to process
* @returns {Promise<{dst: string}>} reutrns a promise with the value
*/
@Cordova()
isDayLightSavingsTime(date: Date): Promise<{ dst: string }> { return; }
/**
* Returns the first day of the week according to the client's user preferences and calendar.
* @returns {Promise<{value: string}>} returns a promise with the value
*/
@Cordova()
getFirstDayOfWeek(): Promise<{ value: string }> { return; }
/**
* Returns a number formatted as a string according to the client's user preferences.
* @param numberToConvert {Number} The number to convert
* @param options {Object} Object with property `type` that can be set to: decimal, percent, or currency.
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
numberToString(numberToConvert: number, options: { type: string }): Promise<{ value: string }> { return; }
/**
*
* @param {string} stringToConvert String you want to conver to a number
* @param options The type of number you want to return. Can be decimal, percent, or currency.
* @returns {Promise<{ value: number | string }>} Returns a promise with the value.
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
stringToNumber(stringToConvert: string, options: { type: string }): Promise<{ value: number | string }> { return; }
/**
* Returns a pattern string to format and parse numbers according to the client's user preferences.
* @param options Can be decimal, percent, or currency.
* @returns {Promise<{ pattern: string, symbol: string, fraction: number, rounding: number, positive: string, negative: string, decimal: string, grouping: string }>}
*/
@Cordova({
callbackOrder: 'reverse'
})
getNumberPattern(options: { type: string }): Promise<{ pattern: string, symbol: string, fraction: number, rounding: number, positive: string, negative: string, decimal: string, grouping: string }> { return; }
/**
* Returns a pattern string to format and parse currency values according to the client's user preferences and ISO 4217 currency code.
* @param {string} currencyCode Currency Code.A
* @returns {Promise<{ pattern: string, code: string, fraction: number, rounding: number, decimal: number, grouping: string }>}
*/
@Cordova()
getCurrencyPattern(currencyCode: string): Promise<{ pattern: string, code: string, fraction: number, rounding: number, decimal: number, grouping: string }> { return; }
}
src/@ionic-native/plugins/google-analytics/index.ts
+214
View File
@@ -0,0 +1,214 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
declare var window;
/**
* @name Google Analytics
* @description
* This plugin connects to Google's native Universal Analytics SDK
* Prerequisites:
* - A Cordova 3.0+ project for iOS and/or Android
* - A Mobile App property through the Google Analytics Admin Console
* - (Android) Google Play Services SDK installed via [Android SDK Manager](https://developer.android.com/sdk/installing/adding-packages.html)
* @usage
* ```typescript
* import { GoogleAnalytics } from '@ionic-native/google-analytics';
*
* constructor(private ga: GoogleAnalytics) { }
*
* ...
*
* this.ga.startTrackerWithId('YOUR_TRACKER_ID')
* .then(() => {
* console.log('Google analytics is ready now');
* // Tracker is ready
* // You can now track pages or set additional information such as AppVersion or UserId
* })
* .catch(e => console.log('Error starting GoogleAnalytics', e));
*
*
* ```
*/
@Plugin({
pluginName: 'GoogleAnalytics',
plugin: 'cordova-plugin-google-analytics',
pluginRef: 'ga',
repo: 'https://github.com/danwilson/google-analytics-plugin',
platforms: ['Android', 'iOS', 'Browser']
})
@Injectable()
export class GoogleAnalytics {
/**
* In your 'deviceready' handler, set up your Analytics tracker.
* https://developers.google.com/analytics/devguides/collection/analyticsjs/
* @param {string} id Your Google Analytics Mobile App property
* @param {number} interval Optional dispatch period in seconds. Defaults to 30.
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 2,
errorIndex: 3
})
startTrackerWithId(id: string, interval?: number): Promise<any> { return; }
/**
* Enabling Advertising Features in Google Analytics allows you to take advantage of Remarketing, Demographics & Interests reports, and more
* @param allow {boolean}
* @returns {Promise<any>}
*/
@Cordova()
setAllowIDFACollection(allow: boolean): Promise<any> { return; }
/**
* Set a UserId
* https://developers.google.com/analytics/devguides/collection/analyticsjs/user-id
* @param {string} id User ID
* @returns {Promise<any>}
*/
@Cordova()
setUserId(id: string): Promise<any> { return; }
/**
* Set a anonymize Ip address
* @param anonymize {boolean} Set to true to anonymize the IP Address
* @returns {Promise<any>}
*/
@Cordova()
setAnonymizeIp(anonymize: boolean): Promise<any> { return; }
/**
* Sets the app version
* @param appVersion {string} App version
* @returns {Promise<any>}
*/
@Cordova()
setAppVersion(appVersion: string): Promise<any> { return; }
/**
* Set OptOut
* @param optout {boolean}
* @returns {Promise<any>}
*/
@Cordova()
setOptOut(optout: boolean): Promise<any> { return; }
/**
* Enable verbose logging
* @returns {Promise<any>}
*/
@Cordova()
debugMode(): Promise<any> { return; }
/**
* Track custom metric
* @param key {string}
* @param value {any}
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 2,
errorIndex: 3
})
trackMetric(key: string, value?: any): Promise<any> { return; }
/**
* Track a screen
* https://developers.google.com/analytics/devguides/collection/analyticsjs/screens
*
* @param title {string} Screen title
* @param campaignUrl {string} Campaign url for measuring referrals
* @param newSession {boolean} Set to true to create a new session
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 3,
errorIndex: 4
})
trackView(title: string, campaignUrl?: string, newSession?: boolean): Promise<any> { return; }
/**
* Add a Custom Dimension
* https://developers.google.com/analytics/devguides/platform/customdimsmets
* @param key {number}
* @param value {string}
* @returns {Promise<any>}
*/
@Cordova()
addCustomDimension(key: number, value: string): Promise<any> { return; }
/**
* Track an event
* https://developers.google.com/analytics/devguides/collection/analyticsjs/events
* @param category {string}
* @param action {string}
* @param label {string}
* @param value {number}
* @param newSession {boolean} Set to true to create a new session
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 5,
errorIndex: 6
})
trackEvent(category: string, action: string, label?: string, value?: number, newSession?: boolean): Promise<any> { return; }
/**
* Track an exception
* @param description {string}
* @param fatal {boolean}
* @returns {Promise<any>}
*/
@Cordova()
trackException(description: string, fatal: boolean): Promise<any> { return; }
/**
* Track User Timing (App Speed)
* @param category {string}
* @param intervalInMilliseconds {number}
* @param variable {string}
* @param label {string}
* @returns {Promise<any>}
*/
@Cordova()
trackTiming(category: string, intervalInMilliseconds: number, variable: string, label: string): Promise<any> { return; }
/**
* Add a Transaction (Ecommerce)
* https://developers.google.com/analytics/devguides/collection/analyticsjs/ecommerce#addTrans
* @param id {string}
* @param affiliation {string}
* @param revenue {number}
* @param tax {number}
* @param shipping {number}
* @param currencyCode {string}
* @returns {Promise<any>}
*/
@Cordova()
addTransaction(id: string, affiliation: string, revenue: number, tax: number, shipping: number, currencyCode: string): Promise<any> { return; }
/**
* Add a Transaction Item (Ecommerce)
* https://developers.google.com/analytics/devguides/collection/analyticsjs/ecommerce#addItem
* @param {string} id
* @param {string} name
* @param {string} sku
* @param {string} category
* @param {number} price
* @param {number} quantity
* @param {string} currencyCode
* @returns {Promise<any>}
*/
@Cordova()
addTransactionItem(id: string, name: string, sku: string, category: string, price: number, quantity: number, currencyCode: string): Promise<any> { return; }
/**
* Enable/disable automatic reporting of uncaught exceptions
* @param shouldEnable {boolean}
* @returns {Promise<any>}
*/
@Cordova()
enableUncaughtExceptionReporting(shouldEnable: boolean): Promise<any> { return; }
}
src/@ionic-native/plugins/google-maps/index.ts
+1767
View File
File diff suppressed because it is too large Load Diff
src/@ionic-native/plugins/google-plus/index.ts
+66
View File
@@ -0,0 +1,66 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Google Plus
* @description
* @usage
* ```typescript
* import { GooglePlus } from '@ionic-native/google-plus';
*
* constructor(private googlePlus: GooglePlus) { }
*
* ...
*
* this.googlePlus.login()
* .then(res => console.log(res))
* .catch(err => console.error(err));
*
* ```
*/
@Plugin({
pluginName: 'GooglePlus',
plugin: 'cordova-plugin-googleplus',
pluginRef: 'window.plugins.googleplus',
repo: 'https://github.com/EddyVerbruggen/cordova-plugin-googleplus',
platforms: ['Web', 'Android', 'iOS'],
install: 'ionic plugin add cordova-plugin-googleplus --variable REVERSED_CLIENT_ID=myreversedclientid',
installVariables: ['REVERSED_CLIENT_ID']
})
@Injectable()
export class GooglePlus {
/**
* The login function walks the user through the Google Auth process.
* @param options
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
login(options?: any): Promise<any> { return; }
/**
* You can call trySilentLogin to check if they're already signed in to the app and sign them in silently if they are.
* @param options
* @returns {Promise<any>}
*/
@Cordova()
trySilentLogin(options?: any): Promise<any> { return; }
/**
* This will clear the OAuth2 token.
* @returns {Promise<any>}
*/
@Cordova()
logout(): Promise<any> { return; }
/**
* This will clear the OAuth2 token, forget which account was used to login, and disconnect that account from the app. This will require the user to allow the app access again next time they sign in. Be aware that this effect is not always instantaneous. It can take time to completely disconnect.
* @returns {Promise<any>}
*/
@Cordova()
disconnect(): Promise<any> { return; }
}
src/@ionic-native/plugins/gyroscope/index.ts
+109
View File
@@ -0,0 +1,109 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
import { Injectable } from '@angular/core';
declare var navigator: any;
/**
* @hidden
*/
export interface GyroscopeOrientation {
/**
* Represent x-axis
*/
x: number;
/**
* Represent y-axis
*/
y: number;
/**
* Represent z-axis
*/
z: number;
/**
* Represent timestamp of sensor read. Default is 10000ms
*/
timestamp: number;
}
/**
* @hidden
*/
export interface GyroscopeOptions {
/**
* Represent how often (in milliseconds) sensor should be read. Default is 10000 ms
*/
frequency: number;
}
/**
* @name Gyroscope
* @description Read Gyroscope sensor data
* @usage
* ```
* import { Gyroscope, GyroscopeOrientation, GyroscopeOptions } from '@ionic-native/gyroscope';
*
*
* constructor(private gyroscope: Gyroscope) { }
*
* ...
*
*
* let options: GyroscopeOptions = {
* frequency: 1000
* };
*
* this.gyroscope.getCurrent(options)
* .then((orientation: GyroscopeOrientation) => {
* console.log(orientation.x, orientation.y, orientation.z, orientation.timestamp);
* })
* .catch()
*
*
* this.gyroscope.watch()
* .subscribe((orientation: GyroscopeOrientation) => {
* console.log(orientation.x, orientation.y, orientation.z, orientation.timestamp);
* });
*
* ```
* @interfaces
* GyroscopeOrientation
* GyroscopeOptions
*/
@Plugin({
pluginName: 'Gyroscope',
plugin: 'cordova-plugin-gyroscope',
pluginRef: 'navigator.gyroscope',
repo: 'https://github.com/NeoLSN/cordova-plugin-gyroscope',
platforms: ['Android', 'iOS']
})
@Injectable()
export class Gyroscope {
/**
* Watching for gyroscope sensor changes
* @param options {GyroscopeOptions} (optional)
* @return {Observable<GyroscopeOrientation>} Returns an Observable that resolves GyroscopeOrientation
*/
watch(options?: GyroscopeOptions): Observable<GyroscopeOrientation> {
return new Observable<GyroscopeOrientation> (
(observer: any) => {
let watchId = navigator.gyroscope.watch(observer.next.bind(observer), observer.next.bind(observer), options);
return () => navigator.gyroscope.clearWatch(watchId);
}
);
}
/**
* Get current data from gyroscope sensor
* @param options {GyroscopeOptions} (optional)
* @return {Promise<GyroscopeOrientation>} Returns a promise that resolves GyroscopeOrientation
*/
@Cordova({
callbackOrder: 'reverse'
})
getCurrent(options?: GyroscopeOptions): Promise<GyroscopeOrientation> { return; }
}
src/@ionic-native/plugins/header-color/index.ts
+42
View File
@@ -0,0 +1,42 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Header Color
* @description
* Cordova plugin to change color of header in multitask view
*
* @usage
* ```typescript
* import { HeaderColor } from '@ionic-native/header-color';
*
* constructor(private headerColor: HeaderColor) { }
*
* ...
*
* this.headerColor.tint("#becb29");
* ```
*/
@Plugin({
pluginName: 'HeaderColor',
plugin: 'cordova-plugin-headercolor',
pluginRef: 'plugins.headerColor',
repo: 'https://github.com/tomloprod/cordova-plugin-headercolor',
platforms: ['Android']
})
@Injectable()
export class HeaderColor {
/**
* Set a color to the task header
* @param color {string} The hex value of the color
* @returns {Promise<any>}
*/
@Cordova({
callbackStyle: 'object',
successName: 'success',
errorName: 'failure'
})
tint(color: string): Promise<any> { return; }
}
src/@ionic-native/plugins/health/index.ts
+313
View File
@@ -0,0 +1,313 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Injectable } from '@angular/core';
/**
* @hidden
*/
export interface HealthQueryOptions {
/**
* Start date from which to get data
*/
startDate: Date;
/**
* End date from which to get data
*/
endDate: Date;
/**
* Datatype to be queried (see https://github.com/dariosalvi78/cordova-plugin-health#supported-data-types)
*/
dataType: string;
/**
* Optional limit the number of values returned. Defaults to 1000
*/
limit?: number;
/**
* Optional indicator to sort values ascending or descending
*/
ascending?: boolean;
/**
* In Android, it is possible to query for "raw" steps or to select those as filtered by the Google Fit app.
* In the latter case the query object must contain the field filtered: true.
*/
filtered?: boolean;
}
/**
* @hidden
*/
export interface HealthQueryOptionsAggregated {
/**
* Start date from which to get data
*/
startDate: Date;
/**
* End date from which to get data
*/
endDate: Date;
/**
* Datatype to be queried (see https://github.com/dariosalvi78/cordova-plugin-health#supported-data-types)
*/
dataType: string;
/**
* if specified, aggregation is grouped an array of "buckets" (windows of time),
* supported values are: 'hour', 'day', 'week', 'month', 'year'.
*/
bucket: string;
}
/**
* @hidden
*/
export interface HealthStoreOptions {
/**
* Start date from which to get data
*/
startDate: Date;
/**
* End date from which to get data
*/
endDate: Date;
/**
* Datatype to be queried (see https://github.com/dariosalvi78/cordova-plugin-health#supported-data-types)
*/
dataType: string;
/**
* Value of corresponding Datatype (see "Overview of valid datatypes")
*/
value: string;
/**
* The source that produced this data. In iOS this is ignored and
* set automatically to the name of your app.
*/
sourceName: string;
/**
* The complete package of the source that produced this data.
* In Android, if not specified, it's assigned to the package of the App. In iOS this is ignored and
* set automatically to the bunde id of the app.
*/
sourceBundleId: string;
}
/**
* @hidden
*/
export interface HealthData {
/**
* Start date from which to get data
*/
startDate: Date;
/**
* End date from which to get data
*/
endDate: Date;
/**
* Value of corresponding Datatype (see https://github.com/dariosalvi78/cordova-plugin-health#supported-data-types)
*/
value: string;
/**
* Unit of corresponding value of Datatype (see https://github.com/dariosalvi78/cordova-plugin-health#supported-data-types)
*/
unit: string;
/**
* The source that produced this data. In iOS this is ignored and
* set automatically to the name of your app.
*/
sourceName: string;
/**
* The complete package of the source that produced this data.
* In Android, if not specified, it's assigned to the package of the App. In iOS this is ignored and
* set automatically to the bunde id of the app.
*/
sourceBundleId: string;
}
/**
* @name Health
* @description
* A plugin that abstracts fitness and health repositories like Apple HealthKit or Google Fit.
*
* @usage
* ```
* import { Health } from '@ionic-native/health';
*
*
* constructor(private health: Health) { }
*
* ...
*
* this.health.isAvailable()
* .then(res => console.log(res))
* .catch(e => console.log(e));
*
*
* ```
* See description at https://github.com/dariosalvi78/cordova-plugin-health for a full list of Datatypes and see examples.
*
* @interfaces
* HealthQueryOptions
* HealthQueryOptionsAggregated
* HealthStoreOptions
* HealthData
*/
@Injectable()
@Plugin({
pluginName: 'Health',
plugin: 'cordova-plugin-health',
pluginRef: 'navigator.health',
repo: 'https://github.com/dariosalvi78/cordova-plugin-health'
})
export class Health {
/**
* Tells if either Google Fit or HealthKit are available.
*
* @return {Promise<boolean>}
*/
@Cordova({
callbackOrder: 'reverse'
})
isAvailable(): Promise<boolean> { return; }
/**
* Checks if recent Google Play Services and Google Fit are installed. If the play services are not installed,
* or are obsolete, it will show a pop-up suggesting to download them. If Google Fit is not installed,
* it will open the Play Store at the location of the Google Fit app.
* The plugin does not wait until the missing packages are installed, it will return immediately.
* If both Play Services and Google Fit are available, this function just returns without any visible effect.
*
* This function is only available on Android.
*
* @return {Promise<any>}
*/
@Cordova({
callbackOrder: 'reverse'
})
promptInstallFit(): Promise<any> { return; }
/**
* Requests read and write access to a set of data types. It is recommendable to always explain why the app
* needs access to the data before asking the user to authorize it.
* This function must be called before using the query and store functions, even if the authorization has already
* been given at some point in the past.
*
* Quirks of requestAuthorization()
* In Android, it will try to get authorization from the Google Fit APIs.
* It is necessary that the app's package name and the signing key are registered in the Google API console.
* In Android, be aware that if the activity is destroyed (e.g. after a rotation) or is put in background,
* the connection to Google Fit may be lost without any callback. Going through the authorization will ensure that
* the app is connected again.
* In Android 6 and over, this function will also ask for some dynamic permissions if needed
* (e.g. in the case of "distance", it will need access to ACCESS_FINE_LOCATION).
*
* @param {Array<String>} datatypes a list of data types you want to be granted access to
*
* @return {Promise<any>}
*/
@Cordova()
requestAuthorization(datatypes: Array<string>): Promise<any> { return; }
/**
* Check if the app has authorization to read/write a set of datatypes.
* This function is similar to requestAuthorization() and has similar quirks.
*
* @param {Array<String>} datatypes a list of data types you want to be granted access to
* @return {Promise<boolean>} Returns a promise that resolves with a boolean that indicates the authorization status
*/
@Cordova()
isAuthorized(datatypes: Array<string>): Promise<boolean> { return; }
/**
* Gets all the data points of a certain data type within a certain time window.
* Warning: if the time span is big, it can generate long arrays!
*
* Quirks of query()
*
* In iOS, the amount of datapoints is limited to 1000 by default.
* You can override this by adding a limit: xxx to your query object.
* In iOS, datapoints are ordered in an descending fashion (from newer to older).
* You can revert this behaviour by adding ascending: true to your query object.
* In Android, it is possible to query for "raw" steps or to select those as filtered by the Google Fit app.
* In the latter case the query object must contain the field filtered: true.
* In Google Fit, calories.basal is returned as an average per day, and usually is not available in all days.
* In Google Fit, calories.active is computed by subtracting the basal calories from the total.
* As basal energy expenditure, an average is computed from the week before endDate.
* While Google Fit calculates basal and active calories automatically,
* HealthKit needs an explicit input from some app.
* When querying for activities, Google Fit is able to determine some activities automatically
* (still, walking, running, biking, in vehicle), while HealthKit only relies on the input of
* the user or of some external app.
* When querying for activities, calories and distance are also provided in HealthKit (units are kcal and meters) and
* never in Google Fit.
* When querying for nutrition, Google Fit always returns all the nutrition elements it has,
* while HealthKit returns only those that are stored as correlation. To be sure to get all stored the quantities
* (regardless of they are stored as correlation or not), it's better to query single nutrients.
* nutrition.vitamin_a is given in micrograms in HealthKit and International Unit in Google Fit.
* Automatic conversion is not trivial and depends on the actual substance.
*
* @param queryOptions {HealthQueryOptions}
* @return {Promise<HealthData>}
*/
@Cordova()
query(queryOptions: HealthQueryOptions): Promise<HealthData> { return; }
/**
* Gets aggregated data in a certain time window. Usually the sum is returned for the given quantity.
*
* Quirks of queryAggregated()
* In Android, to query for steps as filtered by the Google Fit app, the flag filtered:
* true must be added into the query object.
* When querying for activities, calories and distance are provided
* when available in HealthKit and never in Google Fit.
* In Android, the start and end dates returned are the date of the first and the last available samples.
* If no samples are found, start and end may not be set.
* When bucketing, buckets will include the whole hour / day / month / week / year where start and end times
* fall into. For example, if your start time is 2016-10-21 10:53:34,
* the first daily bucket will start at 2016-10-21 00:00:00.
* Weeks start on Monday.
* When querying for nutrition, HealthKit returns only those that are stored as correlation.
* To be sure to get all the stored quantities, it's better to query single nutrients.
* nutrition.vitamin_a is given in micrograms in HealthKit and International Unit in Google Fit.
*
* @param queryOptionsAggregated {HealthQueryOptionsAggregated}
* @return {Promise<HealthData[]>}
*/
@Cordova()
queryAggregated(queryOptionsAggregated: HealthQueryOptionsAggregated): Promise<HealthData[]> { return; }
/**
* Stores a data point.
*
* Quirks of store()
*
* Google Fit doesn't allow you to overwrite data points that overlap with others already stored of the same type (see here). At the moment there is no support for update nor delete.
* In iOS you cannot store the total calories, you need to specify either basal or active. If you use total calories, the active ones will be stored.
* In Android you can only store active calories, as the basal are estimated automatically. If you store total calories, these will be treated as active.
* In iOS distance is assumed to be of type WalkingRunning, if you want to explicitly set it to Cycling you need to add the field cycling: true.
* In iOS storing the sleep activities is not supported at the moment.
* Storing of nutrients is not supported at the moment.
* @param storeOptions
* @return {Promise<any>}
*/
@Cordova()
store(storeOptions: HealthStoreOptions): Promise<any> { return; }
}
src/@ionic-native/plugins/hotspot/index.ts
+374
View File
@@ -0,0 +1,374 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface HotspotConnectionInfo {
/**
* The service set identifier (SSID) of the current 802.11 network.
*/
SSID: string;
/**
* The basic service set identifier (BSSID) of the current access point.
*/
BSSID: string;
/**
* The current link speed in Mbps
*/
linkSpeed: string;
/**
* The IP Address
*/
IPAddress: string;
/**
* Each configured network has a unique small integer ID, used to identify the network when performing operations on the supplicant.
*/
networkID: string;
}
export interface HotspotNetwork {
/**
* Human readable network name
*/
SSID: string;
/**
* MAC Address of the access point
*/
BSSID: string;
/**
* The primary 20 MHz frequency (in MHz) of the channel over which the client is communicating with the access point.
*/
frequency: number;
/**
* The detected signal level in dBm, also known as the RSSI.
*/
level: number;
/**
* Timestamp in microseconds (since boot) when this result was last seen.
*/
timestamp: number;
/**
* Describes the authentication, key management, and encryption schemes supported by the access point.
*/
capabilities: string;
}
export interface HotspotNetworkConfig {
/**
* Device IP Address
*/
deviceIPAddress: string;
/**
* Device MAC Address
*/
deviceMacAddress: string;
/**
* Gateway IP Address
*/
gatewayIPAddress: string;
/**
* Gateway MAC Address
*/
gatewayMacAddress: string;
}
export interface HotspotDevice {
/**
* Hotspot IP Address
*/
ip: string;
/**
* Hotspot MAC Address
*/
mac: string;
}
/**
* @beta
* @name Hotspot
* @description
* @usage
* ```typescript
* import { Hotspot, HotspotNetwork } from '@ionic-native/hotspot';
*
* constructor(private hotspot: Hotspot) { }
*
* ...
*
*
* this.hotspot.scanWifi().then((networks: Array<HotspotNetwork>) => {
* console.log(networks);
* });
*
* ```
* @interfaces
* HotspotConnectionInfo
* HotspotNetwork
* HotspotNetworkConfig
* HotspotDevice
*/
@Plugin({
pluginName: 'Hotspot',
plugin: 'cordova-plugin-hotspot',
pluginRef: 'cordova.plugins.hotspot',
repo: 'https://github.com/hypery2k/cordova-hotspot-plugin',
platforms: ['Android']
})
@Injectable()
export class Hotspot {
/**
* @returns {Promise<boolean>}
*/
@Cordova()
isAvailable(): Promise<boolean> { return; }
/**
* @returns {Promise<boolean>}
*/
@Cordova()
toggleWifi(): Promise<boolean> { return; }
/**
* Configures and starts hotspot with SSID and Password
*
* @param {string} SSID - SSID of your new Access Point
* @param {string} mode - encryption mode (Open, WEP, WPA, WPA_PSK)
* @param {string} password - password for your new Access Point
*
* @returns {Promise<void>} - Promise to call once hotspot is started, or reject upon failure
*/
@Cordova()
createHotspot(ssid: string, mode: string, password: string): Promise<void> { return; }
/**
* Turns on Access Point
*
* @returns {Promise<boolean>} - true if AP is started
*/
@Cordova()
startHotspot(): Promise<boolean> { return; }
/**
* Configures hotspot with SSID and Password
*
* @param {string} SSID - SSID of your new Access Point
* @param {string} mode - encryption mode (Open, WEP, WPA, WPA_PSK)
* @param {string} password - password for your new Access Point
*
* @returns {Promise<void>} - Promise to call when hotspot is configured, or reject upon failure
*/
@Cordova()
configureHotspot(ssid: string, mode: string, password: string): Promise<void> { return; }
/**
* Turns off Access Point
*
* @returns {Promise<boolean>} - Promise to turn off the hotspot, true on success, false on failure
*/
@Cordova()
stopHotspot(): Promise<boolean> { return; }
/**
* Checks if hotspot is enabled
*
* @returns {Promise<void>} - Promise that hotspot is enabled, rejected if it is not enabled
*/
@Cordova()
isHotspotEnabled(): Promise<void> { return; }
/**
* @returns {Promise<Array<HotspotDevice>>}
*/
@Cordova()
getAllHotspotDevices(): Promise<Array<HotspotDevice>> { return; }
/**
* Connect to a WiFi network
*
* @param {string} ssid
* SSID to connect
* @param {string} password
* password to use
*
* @returns {Promise<void>}
* Promise that connection to the WiFi network was successfull, rejected if unsuccessful
*/
@Cordova()
connectToWifi(ssid: string, password: string): Promise<void> { return; }
/**
* Connect to a WiFi network
*
* @param {string} ssid
* SSID to connect
* @param {string} password
* Password to use
* @param {string} authentication
* Authentication modes to use (LEAP, SHARED, OPEN)
* @param {string[]} encryption
* Encryption modes to use (CCMP, TKIP, WEP104, WEP40)
*
* @returns {Promise<void>}
* Promise that connection to the WiFi network was successfull, rejected if unsuccessful
*/
@Cordova()
connectToWifiAuthEncrypt(ssid: string, password: string, authentication: string, encryption: Array<string>): Promise<void> { return; }
/**
* Add a WiFi network
*
* @param {string} ssid
* SSID of network
* @param {string} mode
* Authentication mode of (Open, WEP, WPA, WPA_PSK)
* @param {string} password
* Password for network
*
* @returns {Promise<void>}
* Promise that adding the WiFi network was successfull, rejected if unsuccessful
*/
@Cordova()
addWifiNetwork(ssid: string, mode: string, password: string): Promise<void> { return; }
/**
* Remove a WiFi network
*
* @param {string} ssid
* SSID of network
*
* @returns {Promise<void>}
* Promise that removing the WiFi network was successfull, rejected if unsuccessful
*/
@Cordova()
removeWifiNetwork(ssid: string): Promise<void> { return; }
/**
* @returns {Promise<boolean>}
*/
@Cordova()
isConnectedToInternet(): Promise<boolean> { return; }
/**
* @returns {Promise<boolean>}
*/
@Cordova()
isConnectedToInternetViaWifi(): Promise<boolean> { return; }
/**
* @returns {Promise<boolean>}
*/
@Cordova()
isWifiOn(): Promise<boolean> { return; }
/**
* @returns {Promise<boolean>}
*/
@Cordova()
isWifiSupported(): Promise<boolean> { return; }
/**
* @returns {Promise<boolean>}
*/
@Cordova()
isWifiDirectSupported(): Promise<boolean> { return; }
/**
* @returns {Promise<Array<HotspotNetwork>>}
*/
@Cordova()
scanWifi(): Promise<Array<HotspotNetwork>> { return; }
/**
* @returns {Promise<Array<HotspotNetwork>>}
*/
@Cordova()
scanWifiByLevel(): Promise<Array<HotspotNetwork>> { return; }
/**
* @returns {Promise<any>}
*/
@Cordova()
startWifiPeriodicallyScan(interval: number, duration: number): Promise<any> { return; }
/**
* @returns {Promise<any>}
*/
@Cordova()
stopWifiPeriodicallyScan(): Promise<any> { return; }
/**
* @returns {Promise<HotspotNetworkConfig>}
*/
@Cordova()
getNetConfig(): Promise<HotspotNetworkConfig> { return; }
/**
* @returns {Promise<HotspotConnectionInfo>}
*/
@Cordova()
getConnectionInfo(): Promise<HotspotConnectionInfo> { return; }
/**
* @returns {Promise<string>}
*/
@Cordova()
pingHost(ip: string): Promise<string> { return; }
/**
* Gets MAC Address associated with IP Address from ARP File
*
* @param {string} ip - IP Address that you want the MAC Address of
*
* @returns {Promise<string>} - A Promise for the MAC Address
*/
@Cordova()
getMacAddressOfHost(ip: string): Promise<string> { return; }
/**
* Checks if IP is live using DNS
*
* @param {string} ip - IP Address you want to test
*
* @returns {Promise<boolean>} - A Promise for whether the IP Address is reachable
*/
@Cordova()
isDnsLive(ip: string): Promise<boolean> { return; }
/**
* Checks if IP is live using socket And PORT
*
* @param {string} ip - IP Address you want to test
*
* @returns {Promise<boolean>} - A Promise for whether the IP Address is reachable
*/
@Cordova()
isPortLive(ip: string): Promise<boolean> { return; }
/**
* Checks if device is rooted
*
* @returns {Promise<boolean>} - A Promise for whether the device is rooted
*/
@Cordova()
isRooted(): Promise<boolean> { return; }
}
src/@ionic-native/plugins/http/index.ts
+165
View File
@@ -0,0 +1,165 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
export interface HTTPResponse {
/**
* The status number of the response
*/
status: number;
/**
* The data that is in the response. This property usually exists when a promise returned by a request method resolves.
*/
data?: any;
/**
* The headers of the response
*/
headers: any;
/**
* Error response from the server. This property usually exists when a promise returned by a request method rejects.
*/
error?: string;
}
/**
* @name HTTP
* @description
* Cordova / Phonegap plugin for communicating with HTTP servers. Supports iOS and Android.
*
* Advantages over Javascript requests:
* - Background threading - all requests are done in a background thread
* - SSL Pinning
*
* @usage
* ```
* import { HTTP } from '@ionic-native/http';
*
* constructor(private http: HTTP) { }
*
* ...
*
* this.http.get('http://ionic.io', {}, {})
* .then(data => {
*
* console.log(data.status);
* console.log(data.data); // data received by server
* console.log(data.headers);
*
* })
* .catch(error => {
*
* console.log(error.status);
* console.log(error.error); // error message as string
* console.log(error.headers);
*
* });
*
* ```
* @interfaces
* HTTPResponse
*/
@Plugin({
pluginName: 'HTTP',
plugin: 'cordova-plugin-http',
pluginRef: 'cordovaHTTP',
repo: 'https://github.com/wymsee/cordova-HTTP',
platforms: ['Android', 'iOS']
})
@Injectable()
export class HTTP {
/**
* This returns an object representing a basic HTTP Authorization header of the form.
* @param username {string} Username
* @param password {string} Password
* @returns {Object} an object representing a basic HTTP Authorization header of the form {'Authorization': 'Basic base64encodedusernameandpassword'}
*/
@Cordova({ sync: true })
getBasicAuthHeader(username: string, password: string): { Authorization: string; } { return; }
/**
* This sets up all future requests to use Basic HTTP authentication with the given username and password.
* @param username {string} Username
* @param password {string} Password
*/
@Cordova({ sync: true })
useBasicAuth(username: string, password: string): void { }
/**
* Set a header for all future requests. Takes a header and a value.
* @param header {string} The name of the header
* @param value {string} The value of the header
*/
@Cordova({ sync: true })
setHeader(header: string, value: string): void { }
/**
* Enable or disable SSL Pinning. This defaults to false.
*
* To use SSL pinning you must include at least one .cer SSL certificate in your app project. You can pin to your server certificate or to one of the issuing CA certificates. For ios include your certificate in the root level of your bundle (just add the .cer file to your project/target at the root level). For android include your certificate in your project's platforms/android/assets folder. In both cases all .cer files found will be loaded automatically. If you only have a .pem certificate see this stackoverflow answer. You want to convert it to a DER encoded certificate with a .cer extension.
*
* As an alternative, you can store your .cer files in the www/certificates folder.
* @param enable {boolean} Set to true to enable
* @returns {Promise<void>} returns a promise that will resolve on success, and reject on failure
*/
@Cordova()
enableSSLPinning(enable: boolean): Promise<void> { return; }
/**
* Accept all SSL certificates. Or disabled accepting all certificates. Defaults to false.
* @param accept {boolean} Set to true to accept
* @returns {Promise<void>} returns a promise that will resolve on success, and reject on failure
*/
@Cordova()
acceptAllCerts(accept: boolean): Promise<void> { return; }
/**
* Whether or not to validate the domain name in the certificate. This defaults to true.
* @param validate {boolean} Set to true to validate
* @returns {Promise<void>} returns a promise that will resolve on success, and reject on failure
*/
@Cordova()
validateDomainName(validate: boolean): Promise<void> { return; }
/**
* Make a POST request
* @param url {string} The url to send the request to
* @param body {Object} The body of the request
* @param headers {Object} The headers to set for this request
* @returns {Promise<HTTPResponse>} returns a promise that resolve on success, and reject on failure
*/
@Cordova()
post(url: string, body: any, headers: any): Promise<HTTPResponse> { return; }
/**
*
* @param url {string} The url to send the request to
* @param parameters {Object} Parameters to send with the request
* @param headers {Object} The headers to set for this request
* @returns {Promise<HTTPResponse>} returns a promise that resolve on success, and reject on failure
*/
@Cordova()
get(url: string, parameters: any, headers: any): Promise<HTTPResponse> { return; }
/**
*
* @param url {string} The url to send the request to
* @param body {Object} The body of the request
* @param headers {Object} The headers to set for this request
* @param filePath {string} The local path of the file to upload
* @param name {string} The name of the parameter to pass the file along as
* @returns {Promise<HTTPResponse>} returns a promise that resolve on success, and reject on failure
*/
@Cordova()
uploadFile(url: string, body: any, headers: any, filePath: string, name: string): Promise<HTTPResponse> { return; }
/**
*
* @param url {string} The url to send the request to
* @param body {Object} The body of the request
* @param headers {Object} The headers to set for this request
* @param filePath {string} The path to donwload the file to, including the file name.
* @returns {Promise<HTTPResponse>} returns a promise that resolve on success, and reject on failure
*/
@Cordova()
downloadFile(url: string, body: any, headers: any, filePath: string): Promise<HTTPResponse> { return; }
}
src/@ionic-native/plugins/httpd/index.ts
+85
View File
@@ -0,0 +1,85 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export interface HttpdOptions {
/**
* The public root directory for your web server. This path is relative to your app's www directory.
* Default is current directory.
*/
www_root?: string;
/**
* The port number to use.
* Default is 8888
*/
port?: number;
/**
* Setting this option to false will allow remote access to your web server (over any IP).
* Default is false.
*/
localhost_only?: boolean;
}
/**
* @name Httpd
* @description
* Embedded httpd for Cordova apps. Light weight HTTP server.
* @usage
* ```typescript
* import { Httpd, HttpdOptions } from '@ionic-native/httpd';
*
* constructor(private httpd: Httpd) { }
*
* ...
*
*
* let options: HttpdOptions = {
* www_root: 'httpd_root', // relative path to app's www directory
* port: 80,
* localhost_only: false
* };
*
* this.httpd.startServer(options).subscribe((data) => {
* console.log('Server is live');
* });
*
* ```
* @interfaces
* HttpdOptions
*/
@Plugin({
pluginName: 'Httpd',
plugin: 'https://github.com/floatinghotpot/cordova-httpd.git',
pluginRef: 'cordova.plugins.CorHttpd',
repo: 'https://github.com/floatinghotpot/cordova-httpd',
platforms: ['iOS', 'Android']
})
@Injectable()
export class Httpd {
/**
* Starts a web server.
* @param options {HttpdOptions}
* @returns {Observable<string>} Returns an Observable. Subscribe to receive the URL for your web server (if succeeded). Unsubscribe to stop the server.
*/
@Cordova({
observable: true,
clearFunction: 'stopServer'
})
startServer(options?: HttpdOptions): Observable<string> { return; }
/**
* Gets the URL of the running server
* @returns {Promise<string>} Returns a promise that resolves with the URL of the web server.
*/
@Cordova()
getUrl(): Promise<string> { return; }
/**
* Get the local path of the running webserver
* @returns {Promise<string>} Returns a promise that resolves with the local path of the web server.
*/
@Cordova()
getLocalPath(): Promise<string> { return; }
}
src/@ionic-native/plugins/ibeacon/index.ts
+722
View File
@@ -0,0 +1,722 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin, CordovaCheck } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
declare var cordova: any;
export interface Beacon {
/**
* The physical device's identifier.
*/
uuid: string;
/**
* The beacon's major identifier number.
*/
major: number;
/**
* The beacon's major identifier number.
*/
minor: number;
/**
* The proximity of the beacon relative to the phone.
*
* Possible options are:
* ProximityImmediate
* ProximityNear
* ProximityFar
* ProximityUnknown
*/
proximity: 'ProximityImmediate' | 'ProximityNear' | 'ProximityFar' | 'ProximityUnknown';
/**
* Transmission Power of the beacon. A constant emitted by the beacon which indicates what's the expected RSSI at a distance of 1 meter to the beacon.
*/
tx: number;
/**
* Received Signal Strength Indicator. The strength of the beacon's signal when it reaches the device.
* RSSI ranges from aprox -26 (a few inches) to -100 (40-50 m distance).
*/
rssi: number;
/**
* The accuracy of the ranging.
*/
accuracy: number;
}
export interface BeaconRegion {
/**
* A unique identifier for this region.
*/
identifier: string;
/**
* The the beacon identifier the device will "watch" for. Many beacons can share the same uuid.
*/
uuid: string;
/**
* The beacon's major identifier number. Optional, of nothing is supplied
* the plugin will treat it as a wildcard.
*/
major?: number;
/**
* The beacon's minor identifier number. Optional, of nothing is supplied
* the plugin will treat it as a wildcard.
*/
minor?: number;
/**
* If set to true the device will scan for beacons and determine region state anytime
* the device's screen is turned on or off. Useful for debugging.
*/
notifyEntryStateOnDisplay?: boolean;
}
export interface CircularRegion {
/**
* A unique identifier for this region.
*/
identifier: string;
/**
* The latitude of this region.
*/
latitude: number;
/**
* The longitude of this region.
*/
longitude: number;
/**
* The radius of the geofence for this region.
*/
radius: number;
}
export type Region = BeaconRegion | CircularRegion;
export interface IBeaconPluginResult {
/**
* The name of the delegate function that produced the PluginResult object.
*/
eventType: string;
/**
* The region that triggered the event.
*/
region: Region;
/**
* An array of beacon objects
*/
beacons: Beacon[];
/**
* The status of the location permission for iOS.
*/
authorizationStatus: string;
/**
* The state of the phone in relation to the region. Inside/outside for example.
*/
state: 'CLRegionStateInside' | 'CLRegionStateOutside';
/**
* Error message, used only with monitoringDidFailForRegionWithError delegate.
*/
error: string;
}
export interface IBeaconDelegate {
/**
* An observable that publishes information about the location permission authorization status.
*
* @returns {Observable<string>} Returns a string.
*/
didChangeAuthorizationStatus(): Observable<string>;
/**
* An Observable that publishes event data to it's subscribers
* when the native layer is able to determine the device's state.
*
* This event is called when the phone begins starts monitoring,
* when requestStateForRegion is called, etc.
*
* @returns {Observable<IBeaconPluginResult>} Returns a IBeaconPluginResult object with information about the event, region, and beacon(s).
*/
didDetermineStateForRegion(): Observable<IBeaconPluginResult>;
/**
* An Observable that publishes event data to it's subscribers
* when the phone enters a region that it was asked to monitor.
*
* If the user has given the app Always-Location permission, this function
* will be called even when the app is not running on iOS.
* The app will run silently in the background for a small amount of time.
*
* @returns {Observable<IBeaconPluginResult>} Returns a IBeaconPluginResult object with information about the event, region, and beacon(s).
*/
didEnterRegion(): Observable<IBeaconPluginResult>;
/**
* An Observable that publishes event data to it's subscribers
* when the phone exits a region that it was asked to monitor.
*
* If the user has given the app Always-Location permission, this function
* will be called even when the app is not running on iOS.
* The app will run silently in the background for a small amount of time.
*
* @returns {Observable<IBeaconPluginResult>} Returns a IBeaconPluginResult object with information about the event, region, and beacon(s).
*/
didExitRegion(): Observable<IBeaconPluginResult>;
/**
* An Observable that publishes event data to it's subscribers
* each time that the device ranges beacons. Modern Android and iOS devices range
* aproximately once per second.
*
* @returns {Observable<IBeaconPluginResult>} Returns a IBeaconPluginResult object with information about the event, region, and beacon(s).
*/
didRangeBeaconsInRegion(): Observable<IBeaconPluginResult>;
/**
* An Observable that publishes event data to it's subscribers
* when the device begins monitoring a region.
*
* @returns {Observable<IBeaconPluginResult>} Returns a IBeaconPluginResult object with information about the event, region, and beacon(s).
*/
didStartMonitoringForRegion(): Observable<IBeaconPluginResult>;
/**
* An Observable that publishes event data to it's subscribers
* when the device fails to monitor a region.
*
* @returns {Observable<IBeaconPluginResult>} Returns a IBeaconPluginResult object with information about the event, region, and beacon(s).
*/
monitoringDidFailForRegionWithError(): Observable<IBeaconPluginResult>;
/**
* An Observable that publishes event data to it's subscribers
* when the device begins advertising as an iBeacon.
*
* @returns {Observable<IBeaconPluginResult>} Returns a IBeaconPluginResult object with information about the event, region, and beacon(s).
*/
peripheralManagerDidStartAdvertising(): Observable<IBeaconPluginResult>;
/**
* An Observable that publishes event data to it's subscribers
* when the state of the peripheral manager's state updates.
*
*
* @returns {Observable<IBeaconPluginResult>} Returns a IBeaconPluginResult object with information about the event, region, and beacon(s).
*/
peripheralManagerDidUpdateState(): Observable<IBeaconPluginResult>;
}
/**
* @name IBeacon
* @description
* This plugin provides functions for working with iBeacons.
*
* The plugin's API closely mimics the one exposed through the [CLLocationManager](https://developer.apple.com/library/ios/documentation/CoreLocation/Reference/CLLocationManager_Class/index.html) introduced in iOS 7.
*
* @usage
*
* ```typescript
* import { IBeacon } from '@ionic-native/ibeacon';
*
* constructor(private ibeacon: IBeacon) { }
*
* ...
*
*
* // Request permission to use location on iOS
* this.ibeacon.requestAlwaysAuthorization();
* // create a new delegate and register it with the native layer
* let delegate = this.ibeacon.Delegate();
*
* // Subscribe to some of the delegate's event handlers
* delegate.didRangeBeaconsInRegion()
* .subscribe(
* data => console.log('didRangeBeaconsInRegion: ', data),
* error => console.error();
* );
* delegate.didStartMonitoringForRegion()
* .subscribe(
* data => console.log('didStartMonitoringForRegion: ', data),
* error => console.error();
* );
* delegate.didEnterRegion()
* .subscribe(
* data => {
* console.log('didEnterRegion: ', data);
* }
* );
*
* let beaconRegion = this.ibeacon.BeaconRegion('deskBeacon','F7826DA6-ASDF-ASDF-8024-BC5B71E0893E');
*
* this.ibeacon.startMonitoringForRegion(beaconRegion)
* .then(
* () => console.log('Native layer recieved the request to monitoring'),
* error => console.error('Native layer failed to begin monitoring: ', error)
* );
* ```
* @interfaces
* Beacon
* BeaconRegion
* CircularRegion
* IBeaconPluginResult
* IBeaconDelegate
*
*/
@Plugin({
pluginName: 'IBeacon',
plugin: 'cordova-plugin-ibeacon',
pluginRef: 'cordova.plugins.locationManager',
repo: 'https://github.com/petermetz/cordova-plugin-ibeacon',
platforms: ['Android', 'iOS']
})
@Injectable()
export class IBeacon {
/**
* Instances of this class are delegates between the {@link LocationManager} and
* the code that consumes the messages generated on in the native layer.
*
* @returns {IBeaconDelegate} An instance of the type {@type Delegate}.
*/
@CordovaCheck({ sync: true })
Delegate(): IBeaconDelegate {
let delegate = new cordova.plugins.locationManager.Delegate();
delegate.didChangeAuthorizationStatus = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.didChangeAuthorizationStatus = cb;
}
);
};
delegate.didDetermineStateForRegion = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.didDetermineStateForRegion = cb;
}
);
};
delegate.didEnterRegion = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.didEnterRegion = cb;
}
);
};
delegate.didExitRegion = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.didExitRegion = cb;
}
);
};
delegate.didRangeBeaconsInRegion = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.didRangeBeaconsInRegion = cb;
}
);
};
delegate.didStartMonitoringForRegion = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.didStartMonitoringForRegion = cb;
}
);
};
delegate.monitoringDidFailForRegionWithError = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.monitoringDidFailForRegionWithError = cb;
}
);
};
delegate.peripheralManagerDidStartAdvertising = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.peripheralManagerDidStartAdvertising = cb;
}
);
};
delegate.peripheralManagerDidUpdateState = (pluginResult?: IBeaconPluginResult) => {
return new Observable<IBeaconPluginResult>(
(observer: any) => {
let cb = (data: IBeaconPluginResult) => observer.next(data);
return delegate.peripheralManagerDidUpdateState = cb;
}
);
};
cordova.plugins.locationManager.setDelegate(delegate);
return delegate;
}
/**
* Creates a new BeaconRegion
*
* @param {String} identifier @see {CLRegion}
* @param {String} uuid The proximity ID of the beacon being targeted.
* This value must not be blank nor invalid as a UUID.
* @param {Number} major The major value that you use to identify one or more beacons.
* @param {Number} minor The minor value that you use to identify a specific beacon.
* @param {BOOL} notifyEntryStateOnDisplay
*
* @returns {BeaconRegion} Returns the BeaconRegion that was created
*/
@CordovaCheck({ sync: true })
BeaconRegion(identifer: string, uuid: string, major?: number, minor?: number, notifyEntryStateOnDisplay?: boolean): BeaconRegion {
return new cordova.plugins.locationManager.BeaconRegion(identifer, uuid, major, minor, notifyEntryStateOnDisplay);
}
/**
* @returns {IBeaconDelegate} Returns the IBeaconDelegate
*/
@Cordova()
getDelegate(): IBeaconDelegate { return; }
/**
* @param {IBeaconDelegate} delegate An instance of a delegate to register with the native layer.
*
* @returns {IBeaconDelegate} Returns the IBeaconDelegate
*/
@Cordova()
setDelegate(delegate: IBeaconDelegate): IBeaconDelegate { return; }
/**
* Signals the native layer that the client side is ready to consume messages.
* Readiness here means that it has a {IBeaconDelegate} set by the consumer javascript
* code.
*
* The {LocationManager.setDelegate()} will implicitly call this method as well,
* therefore the only case when you have to call this manually is if you don't
* wish to specify a {IBeaconDelegate} of yours.
*
* The purpose of this signaling mechanism is to make the events work when the
* app is being woken up by the Operating System to give it a chance to handle
* region monitoring events for example.
*
* If you don't set a {IBeaconDelegate} and don't call this method manually, an error
* message get emitted in the native runtime and the DOM as well after a certain
* period of time.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer acknowledged the request and started to send events.
*/
@Cordova({otherPromise: true})
onDomDelegateReady(): Promise<void> { return; }
/**
* Determines if bluetooth is switched on, according to the native layer.
* @returns {Promise<boolean>} Returns a promise which is resolved with a {Boolean}
* indicating whether bluetooth is active.
*/
@Cordova({otherPromise: true})
isBluetoothEnabled(): Promise<boolean> { return; }
/**
* Enables Bluetooth using the native Layer. (ANDROID ONLY)
*
* @returns {Promise<void>} Returns a promise which is resolved when Bluetooth
* could be enabled. If not, the promise will be rejected with an error.
*/
@Cordova({otherPromise: true})
enableBluetooth(): Promise<void> { return; }
/**
* Disables Bluetooth using the native Layer. (ANDROID ONLY)
*
* @returns {Promise<void>} Returns a promise which is resolved when Bluetooth
* could be enabled. If not, the promise will be rejected with an error.
*/
@Cordova({otherPromise: true})
disableBluetooth(): Promise<void> { return; }
/**
* Start monitoring the specified region.
*
* If a region of the same type with the same identifier is already being
* monitored for this application,
* it will be removed from monitoring. For circular regions, the region
* monitoring service will prioritize
* regions by their size, favoring smaller regions over larger regions.
*
* This is done asynchronously and may not be immediately reflected in monitoredRegions.
*
* @param {Region} region An instance of {Region} which will be monitored
* by the operating system.
*
* @returns {Promise<string>} Returns a promise which is resolved as soon as the
* native layer acknowledged the dispatch of the monitoring request.
*/
@Cordova({otherPromise: true})
startMonitoringForRegion(region: BeaconRegion): Promise<string> { return; }
/**
* Stop monitoring the specified region. It is valid to call
* stopMonitoringForRegion: for a region that was registered for monitoring
* with a different location manager object, during this or previous
* launches of your application.
*
* This is done asynchronously and may not be immediately reflected in monitoredRegions.
*
* @param {Region} region An instance of {Region} which will be monitored
* by the operating system.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer acknowledged the dispatch of the request to stop monitoring.
*/
@Cordova({otherPromise: true})
stopMonitoringForRegion(region: BeaconRegion): Promise<void> { return; }
/**
* Request state the for specified region. When result is ready
* didDetermineStateForRegion is triggered. This can be any region,
* also those which is not currently monitored.
*
* This is done asynchronously and may not be immediately reflected in monitoredRegions.
*
* @param {Region} region An instance of {Region} which will be monitored
* by the operating system.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer acknowledged the dispatch of the request to stop monitoring.
*/
@Cordova({otherPromise: true})
requestStateForRegion(region: Region): Promise<void> { return; }
/**
* Start ranging the specified beacon region.
*
* If a region of the same type with the same identifier is already being
* monitored for this application, it will be removed from monitoring.
*
* This is done asynchronously and may not be immediately reflected in rangedRegions.
*
* @param {Region} region An instance of {BeaconRegion} which will be monitored
* by the operating system.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer acknowledged the dispatch of the monitoring request.
*/
@Cordova({otherPromise: true})
startRangingBeaconsInRegion(region: BeaconRegion): Promise<void> { return; }
/**
* Stop ranging the specified region. It is valid to call
* stopMonitoringForRegion: for a region that was registered for ranging
* with a different location manager object, during this or previous
* launches of your application.
*
* This is done asynchronously and may not be immediately reflected in rangedRegions.
*
* @param {Region} region An instance of {BeaconRegion} which will be monitored
* by the operating system.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer acknowledged the dispatch of the request to stop monitoring.
*/
@Cordova({otherPromise: true})
stopRangingBeaconsInRegion(region: BeaconRegion): Promise<void> { return; }
/**
* Queries the native layer to determine the current authorization in effect.
*
* @returns {Promise<IBeaconPluginResult>} Returns a promise which is resolved with the
* requested authorization status.
*/
@Cordova({otherPromise: true})
getAuthorizationStatus(): Promise<IBeaconPluginResult> { return; }
/**
* For iOS 8 and above only. The permission model has changed by Apple in iOS 8, making it necessary for apps to
* explicitly request permissions via methods like these:
* <a href="https://developer.apple.com/library/prerelease/iOS/documentation/CoreLocation/Reference/CLLocationManager_Class/index.html#//apple_ref/occ/instm/CLLocationManager/requestWhenInUseAuthorization">requestWhenInUseAuthorization</a>
* <a href="https://developer.apple.com/library/prerelease/iOS/documentation/CoreLocation/Reference/CLLocationManager_Class/index.html#//apple_ref/occ/instm/CLLocationManager/requestAlwaysAuthorization">requestAlwaysAuthorization</a>
*
* If you are using this plugin on Android devices only, you will never have to use this, nor {@code requestAlwaysAuthorization}
* @returns {Promise<void>} Returns a promise that is resolved when the request dialog is shown.
*/
@Cordova({otherPromise: true})
requestWhenInUseAuthorization(): Promise<void> { return; }
/**
* See the documentation of {@code requestWhenInUseAuthorization} for further details.
*
* @returns {Promise<void>} Returns a promise which is resolved when the native layer
* shows the request dialog.
*/
@Cordova({otherPromise: true})
requestAlwaysAuthorization(): Promise<void> { return; }
/**
*
* @returns {Promise<Region[]>} Returns a promise which is resolved with an {Array}
* of {Region} instances that are being monitored by the native layer.
*/
@Cordova({otherPromise: true})
getMonitoredRegions(): Promise<Region[]> { return; }
/**
*
* @returns {Promise<Region[]>} Returns a promise which is resolved with an {Array}
* of {Region} instances that are being ranged by the native layer.
*/
@Cordova({otherPromise: true})
getRangedRegions(): Promise<Region[]> { return; }
/**
* Determines if ranging is available or not, according to the native layer.
* @returns {Promise<boolean>} Returns a promise which is resolved with a {Boolean}
* indicating whether ranging is available or not.
*/
@Cordova({otherPromise: true})
isRangingAvailable(): Promise<boolean> { return; }
/**
* Determines if region type is supported or not, according to the native layer.
*
* @param {Region} region An instance of {Region} which will be checked
* by the operating system.
*
* @returns {Promise<boolean>} Returns a promise which is resolved with a {Boolean}
* indicating whether the region type is supported or not.
*/
@Cordova({otherPromise: true})
isMonitoringAvailableForClass(region: Region): Promise<boolean> { return; }
/**
* Start advertising the specified region.
*
* If a region a different identifier is already being advertised for
* this application, it will be replaced with the new identifier.
*
* This call will accept a valid beacon even when no BlueTooth is available,
* and will start when BlueTooth is powered on. See {IBeaconDelegate.}
*
* @param {Region} region An instance of {Region} which will be advertised
* by the operating system.
* @param {Integer} measuredPower: Optional parameter, if left empty, the device will
* use it's own default value.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer acknowledged the dispatch of the advertising request.
*/
@Cordova({otherPromise: true})
startAdvertising(region: Region, measuredPower: number): Promise<void> { return; }
/**
* Stop advertising as a beacon.
*
* This is done asynchronously and may not be immediately reflected in isAdvertising.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer acknowledged the dispatch of the request to stop advertising.
*/
@Cordova({otherPromise: true})
stopAdvertising(region: Region): Promise<void> { return; }
/**
* Determines if advertising is available or not, according to the native layer.
* @returns {Promise<void>} Returns a promise which is resolved with a {Boolean}
* indicating whether advertising is available or not.
*/
@Cordova({otherPromise: true})
isAdvertisingAvailable(): Promise<boolean> { return; }
/**
* Determines if advertising is currently active, according to the native layer.
* @returns {Promise<void>} Returns a promise which is resolved with a {Boolean}
* indicating whether advertising is active.
*/
@Cordova({otherPromise: true})
isAdvertising(): Promise<boolean> { return; }
/**
* Disables debug logging in the native layer. Use this method if you want
* to prevent this plugin from writing to the device logs.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer has set the logging level accordingly.
*/
@Cordova({otherPromise: true})
disableDebugLogs(): Promise<void> { return; }
/**
* Enables the posting of debug notifications in the native layer. Use this method if you want
* to allow the plugin the posting local notifications.
* This can be very helpful when debugging how to apps behave when launched into the background.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer has set the flag to enabled.
*/
@Cordova({otherPromise: true})
enableDebugNotifications(): Promise<void> { return; }
/**
* Disables the posting of debug notifications in the native layer. Use this method if you want
* to prevent the plugin from posting local notifications.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer has set the flag to disabled.
*/
@Cordova({otherPromise: true})
disableDebugNotifications(): Promise<void> { return; }
/**
* Enables debug logging in the native layer. Use this method if you want
* a debug the inner workings of this plugin.
*
* @returns {Promise<void>} Returns a promise which is resolved as soon as the
* native layer has set the logging level accordingly.
*/
@Cordova({otherPromise: true})
enableDebugLogs(): Promise<void> { return; }
/**
* Appends the provided [message] to the device logs.
* Note: If debug logging is turned off, this won't do anything.
*
* @param {String} message The message to append to the device logs.
*
* @returns {Promise<void>} Returns a promise which is resolved with the log
* message received by the native layer for appending. The returned message
* is expected to be equivalent to the one provided in the original call.
*/
@Cordova({otherPromise: true})
appendToDeviceLog(message: string): Promise<void> { return; }
}
src/@ionic-native/plugins/image-picker/index.ts
+95
View File
@@ -0,0 +1,95 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface ImagePickerOptions {
/**
* max images to be selected, defaults to 15. If this is set to 1, upon selection of a single image, the plugin will return it.
*/
maximumImagesCount?: number;
/**
* Max width to allow images to be
*/
width?: number;
/**
* Max height to allow images to be
*/
height?: number;
/**
* Quality of images, defaults to 100
*/
quality?: number;
/**
* Output type, defaults to 0 (FILE_URI).
*/
outputType?: number;
}
/**
* @name Image Picker
* @description
* Cordova Plugin For Multiple Image Selection
*
* Requires Cordova plugin: `cordova-plugin-image-picker`.
* For more info, please see the https://github.com/wymsee/cordova-imagePicker
*
* @usage
* ```typescript
* import { ImagePicker } from '@ionic-native/image-picker';
*
*
* constructor(private imagePicker: ImagePicker) { }
*
* ...
*
* this.imagePicker.getPictures(options).then((results) => {
* for (var i = 0; i < results.length; i++) {
* console.log('Image URI: ' + results[i]);
* }
* }, (err) => { });
*
* ```
* @interfaces
* ImagePickerOptions
*/
@Plugin({
pluginName: 'ImagePicker',
plugin: 'https://github.com/Telerik-Verified-Plugins/ImagePicker',
pluginRef: 'window.imagePicker',
repo: 'https://github.com/Telerik-Verified-Plugins/ImagePicker'
})
@Injectable()
export class ImagePicker {
/**
* Pick pictures from the library.
* @param {ImagePickerOptions} options
* @returns {Promise<any>} Returns a Promise that resolves the image file URI
* otherwise rejects with an error.
*/
@Cordova({
callbackOrder: 'reverse'
})
getPictures(options: ImagePickerOptions): Promise<any> { return; }
/**
* Check if we have permission to read images
* @returns {Promise<boolean>} Returns a promise that resolves with a boolean that indicates whether we have permission
*/
@Cordova({
platforms: ['Android']
})
hasReadPermission(): Promise<boolean> { return; }
/**
* Request permission to read images
* @returns {Promise<any>}
*/
@Cordova({
platforms: ['Android']
})
requestReadPermission(): Promise<any> { return; }
}
src/@ionic-native/plugins/image-resizer/index.ts
+88
View File
@@ -0,0 +1,88 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface ImageResizerOptions {
/**
* The URI for the image on the device to get scaled
*/
uri: string;
/**
* The width of the new image
*/
width: number;
/**
* The height of the new image
*/
height: number;
/**
* The name of the folder the image should be put
* (Android only)
*/
folderName?: string;
/**
*
* Quality given as Number for the quality of the new image
* (Android and iOS only)
*/
quality?: number;
/**
* A custom name for the file. Default name is a timestamp
* (Android and Windows only)
*/
fileName?: string;
}
/**
* @name Image Resizer
* @description
* Cordova Plugin For Image Resize
*
* Requires plugin `info.protonet.imageresizer` - use the Ionic CLI and type in the following command:
* `ionic plugin add https://github.com/protonet/cordova-plugin-image-resizer.git`
*
* For more info, please see the https://github.com/protonet/cordova-plugin-image-resizer
*
* @usage
* ```typescript
* import { ImageResizer, ImageResizerOptions } from '@ionic-native/image-resizer';
*
* constructor(private imageResizer: ImageResizer) { }
*
* ...
*
* let options = {
* uri: uri,
* folderName: 'Protonet',
* quality: 90,
* width: 1280,
* height: 1280
* } as ImageResizerOptions;
*
* this.imageResizer
* .resize(options)
* .then((filePath: string) => console.log('FilePath', filePath))
* .catch(e => console.log(e));
*
* ```
* @interfaces
* ImageResizerOptions
*/
@Plugin({
pluginName: 'ImageResizer',
plugin: 'https://github.com/protonet/cordova-plugin-image-resizer.git',
pluginRef: 'ImageResizer',
repo: 'https://github.com/protonet/cordova-plugin-image-resizer'
})
@Injectable()
export class ImageResizer {
/**
* @returns {Promise<any>}
*/
@Cordova()
resize(options: ImageResizerOptions): Promise<any> { return; }
}
src/@ionic-native/plugins/in-app-browser/index.ts
+183
View File
@@ -0,0 +1,183 @@
import { Injectable } from '@angular/core';
import { Plugin, CordovaInstance } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/observable/fromEvent';
declare var cordova: any;
export interface InAppBrowserOptions {
/** Set to yes or no to turn the InAppBrowser's location bar on or off. */
location?: 'yes' | 'no';
/** Set to yes to create the browser and load the page, but not show it. The loadstop event fires when loading is complete.
* Omit or set to no (default) to have the browser open and load normally. */
hidden?: 'yes' | 'no';
/** Set to yes to have the browser's cookie cache cleared before the new window is opened. */
clearcache?: 'yes';
/** Set to yes to have the session cookie cache cleared before the new window is opened. */
clearsessioncache?: 'yes';
/** (Android Only) set to yes to show Android browser's zoom controls, set to no to hide them. Default value is yes. */
zoom?: 'yes' | 'no';
/** Set to yes to use the hardware back button to navigate backwards through the InAppBrowser's history.
* If there is no previous page, the InAppBrowser will close. The default value is yes, so you must set it to no if you want the back button to simply close the InAppBrowser. */
hardwareback?: 'yes' | 'no';
/** Set to yes to prevent HTML5 audio or video from autoplaying (defaults to no). */
mediaPlaybackRequiresUserAction?: 'yes' | 'no';
/** (Android Only) Set to yes to make InAppBrowser WebView to pause/resume with the app to stop background audio (this may be required to avoid Google Play issues) */
shouldPauseOnSuspend?: 'yes' | 'no';
/** (iOS Only) Set to a string to use as the Done button's caption. Note that you need to localize this value yourself. */
closebuttoncaption?: string;
/** (iOS Only) Set to yes or no (default is no). Turns on/off the UIWebViewBounce property. */
disallowoverscroll?: 'yes' | 'no';
/** (iOS Only) Set to yes or no to turn the toolbar on or off for the InAppBrowser (defaults to yes) */
toolbar?: 'yes' | 'no';
/** (iOS Only) Set to yes or no to prevent viewport scaling through a meta tag (defaults to no). */
enableViewportScale?: 'yes' | 'no';
/** (iOS Only) Set to yes or no to allow in-line HTML5 media playback, displaying within the browser window rather than a device-specific playback interface.
* The HTML's video element must also include the webkit-playsinline attribute (defaults to no) */
allowInlineMediaPlayback?: 'yes' | 'no';
/** (iOS Only) Set to yes or no to open the keyboard when form elements receive focus via JavaScript's focus() call (defaults to yes). */
keyboardDisplayRequiresUserAction?: 'yes' | 'no';
/** (iOS Only) Set to yes or no to wait until all new view content is received before being rendered (defaults to no). */
suppressesIncrementalRendering?: 'yes' | 'no';
/** (iOS Only) Set to pagesheet, formsheet or fullscreen to set the presentation style (defaults to fullscreen). */
presentationstyle?: 'pagesheet' | 'formsheet' | 'fullscreen';
/** (iOS Only) Set to fliphorizontal, crossdissolve or coververtical to set the transition style (defaults to coververtical). */
transitionstyle?: 'fliphorizontal' | 'crossdissolve' | 'coververtical';
/** (iOS Only) Set to top or bottom (default is bottom). Causes the toolbar to be at the top or bottom of the window. */
toolbarposition?: 'top' | 'bottom';
/** (Windows only) Set to yes to create the browser control without a border around it.
* Please note that if location=no is also specified, there will be no control presented to user to close IAB window. */
fullscreen?: 'yes';
}
export interface InAppBrowserEvent extends Event {
/** the eventname, either loadstart, loadstop, loaderror, or exit. */
type: string;
/** the URL that was loaded. */
url: string;
/** the error code, only in the case of loaderror. */
code: number;
/** the error message, only in the case of loaderror. */
message: string;
}
/**
* @hidden
*/
export class InAppBrowserObject {
private _objectInstance: any;
/**
* Opens a URL in a new InAppBrowser instance, the current browser instance, or the system browser.
* @param url The URL to load.
* @param target The target in which to load the URL, an optional parameter that defaults to _self.
* @param options Options for the InAppBrowser. Optional, defaulting to: location=yes.
* The options string must not contain any blank space, and each feature's
* name/value pairs must be separated by a comma. Feature names are case insensitive.
*/
constructor(url: string, target?: string, options?: string | InAppBrowserOptions) {
try {
if (options && typeof options !== 'string')
options = Object.keys(options).map(key => `${key}=${options[key]}`).join(',');
this._objectInstance = cordova.InAppBrowser.open(url, target, options);
} catch (e) {
window.open(url);
console.warn('Native: InAppBrowser is not installed or you are running on a browser. Falling back to window.open.');
}
}
/**
* Displays an InAppBrowser window that was opened hidden. Calling this has no effect
* if the InAppBrowser was already visible.
*/
@CordovaInstance({ sync: true })
show(): void { }
/**
* Closes the InAppBrowser window.
*/
@CordovaInstance({ sync: true })
close(): void { }
/**
* Hides an InAppBrowser window that is currently shown. Calling this has no effect
* if the InAppBrowser was already hidden.
*/
@CordovaInstance({ sync: true })
hide(): void { }
/**
* Injects JavaScript code into the InAppBrowser window.
* @param script {Object} Details of the script to run, specifying either a file or code key.
* @returns {Promise<any>}
*/
@CordovaInstance()
executeScript(script: { file?: string, code?: string }): Promise<any> { return; }
/**
* Injects CSS into the InAppBrowser window.
* @param css {Object} Details of the script to run, specifying either a file or code key.
* @returns {Promise<any>}
*/
@CordovaInstance()
insertCSS(css: { file?: string, code?: string }): Promise<any> { return; }
/**
* A method that allows you to listen to events happening in the browser.
* @param event {string} Name of the event
* @returns {Observable<InAppBrowserEvent>} Returns back an observable that will listen to the event on subscribe, and will stop listening to the event on unsubscribe.
*/
on(event: string): Observable<InAppBrowserEvent> {
return Observable.fromEvent(this._objectInstance, event);
}
}
/**
* @name In App Browser
* @description Launches in app Browser
* @usage
* ```typescript
* import { InAppBrowser } from '@ionic-native/in-app-browser';
*
* constructor(private iab: InAppBrowser) { }
*
*
* ...
*
*
* const browser = this.iab.create('https://ionic.io');
*
* browser.executeScript(...);
* browser.insertCSS(...);
* browser.close();
*
* ```
* @classes
* InAppBrowserObject
* @interfaces
* InAppBrowserEvent
* InAppBrowserOptions
*/
@Plugin({
pluginName: 'InAppBrowser',
plugin: 'cordova-plugin-inappbrowser',
pluginRef: 'cordova.InAppBrowser',
repo: 'https://github.com/apache/cordova-plugin-inappbrowser'
})
@Injectable()
export class InAppBrowser {
/**
* Opens a URL in a new InAppBrowser instance, the current browser instance, or the system browser.
* @param url {string} The URL to load.
* @param target {string} The target in which to load the URL, an optional parameter that defaults to _self.
* @param options {string} Options for the InAppBrowser. Optional, defaulting to: location=yes.
* The options string must not contain any blank space, and each feature's
* name/value pairs must be separated by a comma. Feature names are case insensitive.
* @returns {InAppBrowserObject}
*/
create(url: string, target?: string, options?: string | InAppBrowserOptions): InAppBrowserObject {
return new InAppBrowserObject(url, target, options);
}
}
src/@ionic-native/plugins/in-app-purchase/index.ts
+127
View File
@@ -0,0 +1,127 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name In App Purchase
* @description
* A lightweight Cordova plugin for in app purchases on iOS/Android.
*
* @usage
* ```ts
* import { InAppPurchase } from '@ionic-native/in-app-purchase';
*
* constructor(private iap: InAppPurchase) { }
*
* ...
*
* this.iap
* .getProducts(['com.yourapp.prod1', 'com.yourapp.prod2', ...])
* .then((products) => {
* console.log(products);
* // [{ productId: 'com.yourapp.prod1', 'title': '...', description: '...', price: '...' }, ...]
* })
* .catch((err) => {
* console.log(err);
* });
*
*
* this.iap
* .buy('com.yourapp.prod1')
* .then((data)=> {
* console.log(data);
* // {
* // transactionId: ...
* // receipt: ...
* // signature: ...
* // }
* })
* .catch((err)=> {
* console.log(err);
* });
*
* ```
*
* @advanced
*
* ```ts
* // fist buy the product...
* this.iap
* .buy('com.yourapp.consumable_prod1')
* .then(data => this.iap.consume(data.productType, data.receipt, data.signature))
* .then(() => console.log('product was successfully consumed!'))
* .catch( err=> console.log(err))
* ```
*/
@Plugin({
pluginName: 'InAppPurchase',
plugin: 'cordova-plugin-inapppurchase',
pluginRef: 'inAppPurchase',
platforms: ['Android', 'iOS'],
repo: 'https://github.com/AlexDisler/cordova-plugin-inapppurchase'
})
@Injectable()
export class InAppPurchase {
/**
* Retrieves a list of full product data from Apple/Google. This method must be called before making purchases.
* @param {array<string>} productId an array of product ids.
* @returns {Promise<any>} Returns a Promise that resolves with an array of objects.
*/
@Cordova({
otherPromise: true
})
getProducts(productId: string[]): Promise<any> { return; }
/**
* Buy a product that matches the productId.
* @param {string} productId A string that matches the product you want to buy.
* @returns {Promise<{transactionId: string, receipt: string, signature: string, productType: string}>} Returns a Promise that resolves with the transaction details.
*/
@Cordova({
otherPromise: true
})
buy(productId: string): Promise<{transactionId: string, receipt: string, signature: string, productType: string}> { return; }
/**
* Same as buy, but for subscription based products.
* @param {string} productId A string that matches the product you want to subscribe to.
* @returns {Promise<{transactionId: string, receipt: string, signature: string, productType: string}>} Returns a Promise that resolves with the transaction details.
*/
@Cordova({
otherPromise: true
})
subscribe(productId: string): Promise<{transactionId: string, receipt: string, signature: string, productType: string}> { return; }
/**
* Call this function after purchasing a "consumable" product to mark it as consumed. On Android, you must consume products that you want to let the user purchase multiple times. If you will not consume the product after a purchase, the next time you will attempt to purchase it you will get the error message:
* @param {string} productType
* @param {string} receipt
* @param {string} signature
* @returns {Promise<any>}
*/
@Cordova({
otherPromise: true
})
consume(productType: string, receipt: string, signature: string): Promise<any> { return; }
/**
* Restore all purchases from the store
* @returns {Promise<any>} Returns a promise with an array of purchases.
*/
@Cordova({
otherPromise: true
})
restorePurchases(): Promise<any> { return; }
/**
* Get the receipt.
* @returns {Promise<string>} Returns a promise that contains the string for the receipt
*/
@Cordova({
otherPromise: true,
platforms: ['iOS']
})
getReceipt(): Promise<string> { return; }
}
src/@ionic-native/plugins/insomnia/index.ts
+56
View File
@@ -0,0 +1,56 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Insomnia
* @description
* Prevent the screen of the mobile device from falling asleep.
*
* @usage
* ```typescript
* import { Insomnia } from '@ionic-native/insomnia';
*
* constructor(private insomnia: Insomnia) { }
*
* ...
*
* this.insomnia.keepAwake()
* .then(
* () => console.log('success'),
* () => console.log('error')
* );
*
* this.insomnia.allowSleepAgain()
* .then(
* () => console.log('success'),
* () => console.log('error')
* );
* ```
*
*/
@Plugin({
pluginName: 'Insomnia',
plugin: 'https://github.com/EddyVerbruggen/Insomnia-PhoneGap-Plugin.git',
pluginRef: 'plugins.insomnia',
repo: 'https://github.com/EddyVerbruggen/Insomnia-PhoneGap-Plugin',
platforms: ['Android', 'iOS', 'Windows Phone 8']
})
@Injectable()
export class Insomnia {
/**
* Keeps awake the application
* @returns {Promise<any>}
*/
@Cordova()
keepAwake(): Promise<any> { return; }
/**
* Allows the application to sleep again
* @returns {Promise<any>}
*/
@Cordova()
allowSleepAgain(): Promise<any> { return; }
}
src/@ionic-native/plugins/instagram/index.ts
+64
View File
@@ -0,0 +1,64 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Instagram
* @description Share a photo with the instagram app
*
* @usage
* ```
* import { Instagram } from '@ionic-native/instagram';
*
* constructor(private instagram: Instagram) { }
*
* ...
*
* this.instagram.share('data:image/png;uhduhf3hfif33', 'Caption')
* .then(() => console.log('Shared!'))
* .catch((error: any) => console.error(error));
*
* ```
*/
@Plugin({
pluginName: 'Instagram',
plugin: 'cordova-instagram-plugin',
pluginRef: 'Instagram',
repo: 'https://github.com/vstirbu/InstagramPlugin'
})
@Injectable()
export class Instagram {
/**
* Detect if the Instagram application is installed on the device.
*
* @returns {Promise<boolean|string>} Returns a promise that returns a boolean value if installed, or the app version on android
*/
@Cordova({
callbackStyle: 'node'
})
isInstalled(): Promise<boolean|string> { return; }
/**
* Share an image on Instagram
* Note: Instagram app stopped accepting pre-filled captions on both iOS and Android. As a work-around, the caption is copied to the clipboard. You have to inform your users to paste the caption.
*
* @param canvasIdOrDataUrl The canvas element id or the dataURL of the image to share
* @param caption The caption of the image
* @returns {Promise<any>} Returns a promise that resolves if the image was shared
*/
@Cordova({
callbackStyle: 'node'
})
share(canvasIdOrDataUrl: string, caption?: string): Promise<any> { return; }
/**
* Share a library asset or video
* @param assetLocalIdentifier A local fileURI
* @returns {Promise<any>} Returns a promise that resolves if the image was shared
*/
@Cordova({
callbackOrder: 'reverse'
})
shareAsset(assetLocalIdentifier: string): Promise<any> { return; }
}
src/@ionic-native/plugins/is-debug/index.ts
+42
View File
@@ -0,0 +1,42 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Is Debug
* @description
* Detect if the app is running in debug mode or not.
* Debug mode is when the app is built and installed locally via xcode / eclipse / the cordova cli etc, compared to release mode when the app was downloaded from the app / play store via an end user.
*
* @usage
* ```
* import { IsDebug } from '@ionic-native/is-debug';
*
* constructor(private isDebug: IsDebug) { }
*
* ...
*
* this.isDebug.getIsDebug()
* .then((isDebug: boolean) => console.log('Is debug:', isDebug))
* .catch((error: any) => console.error(error));
*
* ```
*/
@Plugin({
pluginName: 'IsDebug',
plugin: 'cordova-plugin-is-debug',
pluginRef: 'cordova.plugins.IsDebug',
repo: 'https://github.com/mattlewis92/cordova-plugin-is-debug'
})
@Injectable()
export class IsDebug {
/**
* Determine if an app was installed via xcode / eclipse / the ionic CLI etc
* @returns {Promise<boolean>} Returns a promise that resolves with true if the app was installed via xcode / eclipse / the ionic CLI etc. It will resolve to false if the app was downloaded from the app / play store by the end user.
*/
@Cordova()
getIsDebug(): Promise<boolean> {
return;
}
}
src/@ionic-native/plugins/keyboard/index.ts
+89
View File
@@ -0,0 +1,89 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
/**
* @name Keyboard
* @description
* @usage
* ```typescript
* import { Keyboard } from '@ionic-native/keyboard';
*
* constructor(private keyboard: Keyboard) { }
*
* ...
*
* this.keyboard.show();
*
* this.keyboard.close();
*
* ```
*/
@Plugin({
pluginName: 'Keyboard',
plugin: 'ionic-plugin-keyboard',
pluginRef: 'cordova.plugins.Keyboard',
repo: 'https://github.com/driftyco/ionic-plugin-keyboard'
})
@Injectable()
export class Keyboard {
/**
* Hide the keyboard accessory bar with the next, previous and done buttons.
* @param hide {boolean}
*/
@Cordova({sync: true})
hideKeyboardAccessoryBar(hide: boolean): void { }
/**
* Force keyboard to be shown.
*/
@Cordova({
sync: true,
platforms: ['Android', 'BlackBerry 10', 'Windows']
})
show(): void { }
/**
* Close the keyboard if open.
*/
@Cordova({
sync: true,
platforms: ['iOS', 'Android', 'BlackBerry 10', 'Windows']
})
close(): void { }
/**
* Prevents the native UIScrollView from moving when an input is focused.
* @param disable
*/
@Cordova({
sync: true,
platforms: ['iOS', 'Windows']
})
disableScroll(disable: boolean): void { }
/**
* Creates an observable that notifies you when the keyboard is shown. Unsubscribe to observable to cancel event watch.
* @returns {Observable<any>}
*/
@Cordova({
eventObservable: true,
event: 'native.keyboardshow',
platforms: ['iOS', 'Android', 'BlackBerry 10', 'Windows']
})
onKeyboardShow(): Observable<any> { return; }
/**
* Creates an observable that notifies you when the keyboard is hidden. Unsubscribe to observable to cancel event watch.
* @returns {Observable<any>}
*/
@Cordova({
eventObservable: true,
event: 'native.keyboardhide',
platforms: ['iOS', 'Android', 'BlackBerry 10', 'Windows']
})
onKeyboardHide(): Observable<any> { return; }
}
src/@ionic-native/plugins/launch-navigator/index.ts
+228
View File
@@ -0,0 +1,228 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface LaunchNavigatorOptions {
/**
* name of the navigation app to use for directions. Specify using launchnavigator.APP constants. If not specified, defaults to User Selection.
*/
app?: string;
/**
* nickname to display in app for destination. e.g. "Bob's House".
*/
destinationName?: string;
/**
* Start point of the navigation
*/
start?: string | number[];
/**
* nickname to display in app for start . e.g. "My House".
*/
startName?: string;
/**
* Transportation mode for navigation: "driving", "walking" or "transit". Defaults to "driving" if not specified.
*/
transportMode?: string;
/**
* If true, debug log output will be generated by the plugin. Defaults to false.
*/
enableDebug?: boolean;
/**
* a key/value map of extra app-specific parameters. For example, to tell Google Maps on Android to display Satellite view in "maps" launch mode: `{"t": "k"}`
*/
extras?: any;
/**
* (Android only) mode in which to open Google Maps app: "maps" or "turn-by-turn". Defaults to "maps" if not specified. Specify using launchnavigator.LAUNCH_MODE constants.
*/
launchMode?: string;
/**
* text to display in the native picker which enables user to select which navigation app to launch. Defaults to "Select app for navigation" if not specified.
*/
appSelectionDialogHeader?: string;
/**
* text to display for the cancel button in the native picker which enables user to select which navigation app to launch. Defaults to "Cancel" if not specified.
*/
appSelectionCancelButton?: string;
successCallback?: Function;
errorCallback?: Function;
}
/**
* @name Launch Navigator
* @description
* Requires Cordova plugin: uk.co.workingedge.phonegap.plugin.launchnavigator. For more info, please see the [LaunchNavigator plugin docs](https://github.com/dpa99c/phonegap-launch-navigator).
*
* @usage
* Please refer to the plugin's repo for detailed usage. This docs page only explains the Native wrapper.
*
* ```typescript
* import { LaunchNavigator, LaunchNavigatorOptions } from '@ionic-native/launch-navigator';
*
* constructor(private launchNavigator: LaunchNavigator) { }
*
* ...
*
* let options: LaunchNavigatorOptions = {
* start: 'London, ON',
* app: LaunchNavigator.APPS.UBER
* };
*
* this.launchNavigator.navigate('Toronto, ON', options)
* .then(
* success => console.log('Launched navigator'),
* error => console.log('Error launching navigator', error)
* );
* ```
* @interfaces
* LaunchNavigatorOptions
*/
@Plugin({
pluginName: 'LaunchNavigator',
plugin: 'uk.co.workingedge.phonegap.plugin.launchnavigator',
pluginRef: 'launchnavigator',
repo: 'https://github.com/dpa99c/phonegap-launch-navigator.git'
})
@Injectable()
export class LaunchNavigator {
/**
* Launches navigator app
* @param destination {string|number[]} Location name or coordinates (as string or array)
* @param options {LaunchNavigatorOptions}
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
navigate(
destination: string | number[],
options?: LaunchNavigatorOptions
): Promise<any> { return; }
/**
* Determines if the given app is installed and available on the current device.
* @param app {string}
* @returns {Promise<any>}
*/
@Cordova()
isAppAvailable(app: string): Promise<any> { return; }
/**
* Returns a list indicating which apps are installed and available on the current device.
* @returns {Promise<string[]>}
*/
@Cordova()
availableApps(): Promise<string[]> { return; }
/**
* Returns the display name of the specified app.
* @param app {string}
* @returns {string}
*/
@Cordova({ sync: true })
getAppDisplayName(app: string): string { return; }
/**
* Returns list of supported apps on a given platform.
* @param platform {string}
* @returns {string[]}
*/
@Cordova({ sync: true })
getAppsForPlatform(platform: string): string[] { return; }
/**
* Indicates if an app on a given platform supports specification of transport mode.
* @param app {string} specified as a string, you can use one of the constants, e.g `LaunchNavigator.APP.GOOGLE_MAPS`
* @param platform {string}
* @returns {boolean}
*/
@Cordova({ sync: true })
supportsTransportMode(app: string, platform: string): boolean { return; }
/**
* Returns the list of transport modes supported by an app on a given platform.
* @param app {string}
* @param platform {string}
* @returns {string[]}
*/
@Cordova({ sync: true })
getTransportModes(app: string, platform: string): string[] { return; }
/**
* Indicates if an app on a given platform supports specification of launch mode.
* Note that currently only Google Maps on Android does.
* @param app {string}
* @param platform {string}
* @returns {boolean}
*/
@Cordova({ sync: true })
supportsLaunchMode(app: string, platform: string): boolean { return; }
/**
* Indicates if an app on a given platform supports specification of start location.
* @param app {string}
* @param platform {string}
* @returns {boolean}
*/
@Cordova({ sync: true })
supportsStart(app: string, platform: string): boolean { return; }
/**
* @param app {string}
* @param platform {string}
* @returns {boolean}
*/
@Cordova({ sync: true })
supportsStartName(app: string, platform: string): boolean { return; }
/**
* @param app {string}
* @param platform {string}
* @returns {boolean}
*/
@Cordova({ sync: true })
supportsDestName(app: string, platform: string): boolean { return; }
/**
* @param destination {string | number[]}
* @param options {LaunchNavigatorOptions}
*/
@Cordova({ sync: true })
userSelect(destination: string | number[], options: LaunchNavigatorOptions): void { }
APP: any = {
USER_SELECT: 'user_select',
APPLE_MAPS: 'apple_maps',
GOOGLE_MAPS: 'google_maps',
WAZE: 'waze',
CITYMAPPER: 'citymapper',
NAVIGON: 'navigon',
TRANSIT_APP: 'transit_app',
YANDEX: 'yandex',
UBER: 'uber',
TOMTOM: 'tomtom',
BING_MAPS: 'bing_maps',
SYGIC: 'sygic',
HERE_MAPS: 'here_maps',
MOOVIT: 'moovit'
};
TRANSPORT_MODE: any = {
DRIVING: 'driving',
WALKING: 'walking',
BICYCLING: 'bicycling',
TRANSIT: 'transit'
};
}
src/@ionic-native/plugins/launch-review/index.ts
+42
View File
@@ -0,0 +1,42 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Launch Review
* @description
*
* This launches the native store app in order for the user to leave a review.
* On Android, the plugin opens the the app's storepage in the Play Store where the user can leave a review by pressing the stars to give a rating.
* On iOS, the plugin opens the app's storepage in the App Store and focuses the Review tab, where the user can leave a review by pressing "Write a review".
*
* @usage
* ```
* import { LaunchReview } from '@ionic-native/launch-review';
*
* constructor(private launchReview: LaunchReview) { }
*
* ...
*
* const appId: string = 'yourAppId';
* this.launchReview.launch(appId)
* .then(() => console.log('Successfully launched store app');
* ```
*/
@Plugin({
pluginName: 'LaunchReview',
plugin: 'cordova-launch-review',
pluginRef: 'LaunchReview',
repo: 'https://github.com/dpa99c/cordova-launch-review',
platforms: ['Android', 'iOS']
})
@Injectable()
export class LaunchReview {
/**
* Launch store app using given app ID
* @returns {Promise<void>}
*/
@Cordova()
launch(appId: string): Promise<void> { return; }
}
src/@ionic-native/plugins/linkedin/index.ts
+108
View File
@@ -0,0 +1,108 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Injectable } from '@angular/core';
export type LinkedInLoginScopes = 'r_basicprofile' | 'r_emailaddress' | 'rw_company_admin' | 'w_share';
/**
* @name LinkedIn
* @description
* A Cordova plugin that lets you use LinkedIn Native SDKs for Android and iOS.
*
* Please see the [plugin's repo](https://github.com/zyramedia/cordova-plugin-linkedin#installation) for detailed installation steps.
*
* @usage
* ```
* import { LinkedIn } from 'ionic-native';
*
* constructor(private linkedin: LinkedIn) { }
*
* ...
*
* // check if there is an active session
* this.linkedin.hasActiveSession().then((active) => console.log('has active session?', active));
*
* // login
* const scopes = ['r_basicprofile', 'r_emailaddress', 'rw_company_admin', 'w_share'];
* this.linkedin.login(scopes, true)
* .then(() => console.log('Logged in!')
* .catch(e => console.log('Error logging in', e));
*
*
* // get connections
* this.linkedin.getRequest('people/~')
* .then(res => console.log(res))
* .catch(e => console.log(e));
*
* // share something on profile
* const body = {
* comment: 'Hello world!',
* visibility: {
* code: 'anyone'
* }
* };
*
* this.linkedin.postRequest('~/shares', body)
* .then(res => console.log(res))
* .catch(e => console.log(e));
*
*
* ```
*/
@Plugin({
pluginName: 'LinkedIn',
plugin: 'cordova-plugin-linkedin',
pluginRef: 'cordova.plugins.LinkedIn',
repo: 'https://github.com/zyramedia/cordova-plugin-linkedin',
install: 'ionic plugin add cordova-plugin-linkedin --variable APP_ID=YOUR_APP_ID'
})
@Injectable()
export class LinkedIn {
/**
* Login with the LinkedIn App
* @param scopes {string[]} Scopes to authorize
* @param promptToInstall {boolean} set to true to prompt the user to download the LinkedIn app if it's not installed
* @return {Promise<any>}
*/
@Cordova()
login(scopes: LinkedInLoginScopes[], promptToInstall: boolean): Promise<any> { return; }
/**
* Clears the current session
*/
@Cordova({ sync: true })
logout(): void { }
/**
* Make a get request
* @param path {string} request path
* @return {Promise<any>}
*/
@Cordova()
getRequest(path: string): Promise<any> { return; }
/**
* Make a post request
* @param path {string} request path
* @param body {Object} request body
* @return {Promise<any>}
*/
@Cordova()
postRequest(path: string, body: any): Promise<any> { return; }
/**
* Opens a member's profile
* @param memberId {string} Member id
* @return {Promise<any>}
*/
@Cordova()
openProfile(memberId: string): Promise<any> { return; }
/**
* Checks if there is already an existing active session. This should be used to avoid unecessary login.
* @return {Promise<boolean>} returns a promise that resolves with a boolean that indicates whether there is an active session
*/
@Cordova()
hasActiveSession(): Promise<boolean> { return; }
}
src/@ionic-native/plugins/local-notifications/index.ts
+322
View File
@@ -0,0 +1,322 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
export interface ILocalNotification {
/**
* A unique identifier required to clear, cancel, update or retrieve the local notification in the future
* Default: 0
*/
id?: number;
/**
* First row of the notification
* Default: Empty string (iOS) or the app name (Android)
*/
title?: string;
/**
* Second row of the notification
* Default: Empty string
*/
text?: string;
/**
* The interval at which to reschedule the local notification. That can be a value of second, minute, hour, day, week, month or year
* Default: 0 (which means that the system triggers the local notification once)
*/
every?: string;
/**
* The date and time when the system should deliver the local notification. If the specified value is nil or is a date in the past, the local notification is delivered immediately.
* Default: now ~ new Date()
*/
at?: any;
firstAt?: any;
/**
* The number currently set as the badge of the app icon in Springboard (iOS) or at the right-hand side of the local notification (Android)
* Default: 0 (which means don't show a number)
*/
badge?: number;
/**
* Uri of the file containing the sound to play when an alert is displayed
* Default: res://platform_default
*/
sound?: string;
/**
* Arbitrary data, objects will be encoded to JSON string
* Default: null
*/
data?: any;
/**
* ANDROID ONLY
* Uri of the icon that is shown in the ticker and notification
* Default: res://icon
*/
icon?: string;
/**
* ANDROID ONLY
* Uri of the resource (only res://) to use in the notification layouts. Different classes of devices may return different sizes
* Default: res://ic_popup_reminder
*/
smallIcon?: string;
/**
* ANDROID ONLY
* RGB value for the background color of the smallIcon.
* Default: Androids COLOR_DEFAULT, which will vary based on Android version.
*/
color?: string;
/**
* ANDROID ONLY
* Ongoing notifications differ from regular notifications in the following ways:
* - They are sorted above the regular notifications in the notification panel
* - They do not have an 'X' close button, and are not affected by the "Clear all" button
* Default: false
*/
ongoing?: boolean;
/**
* ANDROID ONLY
* ARGB value that you would like the LED on the device to blink
* Default: FFFFFF
*/
led?: string;
}
/**
* @name Local Notifications
* @description
* This plugin allows you to display local notifications on the device
*
* @usage
* ```typescript
* import { LocalNotifications } from '@ionic-native/local-notifications';
*
*
* constructor(private localNotifications: LocalNotifications) { }
*
* ...
*
*
* // Schedule a single notification
* this.localNotifications.schedule({
* id: 1,
* text: 'Single ILocalNotification',
* sound: isAndroid? 'file://sound.mp3': 'file://beep.caf',
* data: { secret: key }
* });
*
*
* // Schedule multiple notifications
* this.localNotifications.schedule([{
* id: 1,
* text: 'Multi ILocalNotification 1',
* sound: isAndroid ? 'file://sound.mp3': 'file://beep.caf',
* data: { secret:key }
* },{
* id: 2,
* title: 'Local ILocalNotification Example',
* text: 'Multi ILocalNotification 2',
* icon: 'http://example.com/icon.png'
* }]);
*
*
* // Schedule delayed notification
* this.localNotifications.schedule({
* text: 'Delayed ILocalNotification',
* at: new Date(new Date().getTime() + 3600),
* led: 'FF0000',
* sound: null
* });
* ```
* @interfaces
* ILocalNotification
*/
@Plugin({
pluginName: 'LocalNotifications',
plugin: 'de.appplant.cordova.plugin.local-notification',
pluginRef: 'cordova.plugins.notification.local',
repo: 'https://github.com/katzer/cordova-plugin-local-notifications'
})
@Injectable()
export class LocalNotifications {
/**
* Schedules a single or multiple notifications
* @param options {Notification | Array<ILocalNotification>} optional
*/
@Cordova({
sync: true
})
schedule(options?: ILocalNotification | Array<ILocalNotification>): void { }
/**
* Updates a previously scheduled notification. Must include the id in the options parameter.
* @param options {ILocalNotification} optional
*/
@Cordova({
sync: true
})
update(options?: ILocalNotification): void { }
/**
* Clears single or multiple notifications
* @param notificationId {any} A single notification id, or an array of notification ids.
* @returns {Promise<any>} Returns a promise when the notification had been cleared
*/
@Cordova()
clear(notificationId: any): Promise<any> { return; }
/**
* Clears all notifications
* @returns {Promise<any>} Returns a promise when all notifications have cleared
*/
@Cordova({
successIndex: 0,
errorIndex: 2
})
clearAll(): Promise<any> { return; }
/**
* Cancels single or multiple notifications
* @param notificationId {any} A single notification id, or an array of notification ids.
* @returns {Promise<any>} Returns a promise when the notification is canceled
*/
@Cordova()
cancel(notificationId: any): Promise<any> { return; }
/**
* Cancels all notifications
* @returns {Promise<any>} Returns a promise when all notifications are canceled
*/
@Cordova({
successIndex: 0,
errorIndex: 2
})
cancelAll(): Promise<any> { return; }
/**
* Checks presence of a notification
* @param notificationId {number}
* @returns {Promise<boolean>}
*/
@Cordova()
isPresent(notificationId: number): Promise<boolean> { return; }
/**
* Checks is a notification is scheduled
* @param notificationId {number}
* @returns {Promise<boolean>}
*/
@Cordova()
isScheduled(notificationId: number): Promise<boolean> { return; }
/**
* Checks if a notification is triggered
* @param notificationId {number}
* @returns {Promise<boolean>}
*/
@Cordova()
isTriggered(notificationId: number): Promise<boolean> { return; }
/**
* Get all the notification ids
* @returns {Promise<Array<number>>}
*/
@Cordova()
getAllIds(): Promise<Array<number>> { return; }
/**
* Get the ids of triggered notifications
* @returns {Promise<Array<number>>}
*/
@Cordova()
getTriggeredIds(): Promise<Array<number>> { return; }
/**
* Get the ids of scheduled notifications
* @returns {Promise<Array<number>>} Returns a promise
*/
@Cordova()
getScheduledIds(): Promise<Array<number>> { return; }
/**
* Get a notification object
* @param notificationId {any} The id of the notification to get
* @returns {Promise<ILocalNotification>}
*/
@Cordova()
get(notificationId: any): Promise<ILocalNotification> { return; }
/**
* Get a scheduled notification object
* @param notificationId {any} The id of the notification to get
* @returns {Promise<ILocalNotification>}
*/
@Cordova()
getScheduled(notificationId: any): Promise<ILocalNotification> { return; }
/**
* Get a triggered notification object
* @param notificationId The id of the notification to get
* @returns {Promise<ILocalNotification>}
*/
@Cordova()
getTriggered(notificationId: any): Promise<ILocalNotification> { return; }
/**
* Get all notification objects
* @returns {Promise<Array<ILocalNotification>>}
*/
@Cordova()
getAll(): Promise<Array<ILocalNotification>> { return; }
/**
* Get all scheduled notification objects
* @returns {Promise<Array<ILocalNotification>>}
*/
@Cordova()
getAllScheduled(): Promise<Array<ILocalNotification>> { return; }
/**
* Get all triggered notification objects
* @returns {Promise<Array<ILocalNotification>>}
*/
@Cordova()
getAllTriggered(): Promise<Array<ILocalNotification>> { return; }
/**
* Register permission to show notifications if not already granted.
* @returns {Promise<boolean>}
*/
@Cordova()
registerPermission(): Promise<boolean> { return; }
/**
* Informs if the app has the permission to show notifications.
* @returns {Promise<boolean>}
*/
@Cordova()
hasPermission(): Promise<boolean> { return; }
/**
* Sets a callback for a specific event
* @param eventName The name of the event. Available events: schedule, trigger, click, update, clear, clearall, cancel, cancelall
* @param callback Call back function. All events return notification and state parameter. clear and clearall return state parameter only.
*/
@Cordova({
sync: true
})
on(eventName: string, callback: any): void { }
}
src/@ionic-native/plugins/location-accuracy/index.ts
+139
View File
@@ -0,0 +1,139 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name LocationAccuracy
* @description
* This Cordova/Phonegap plugin for Android and iOS to request enabling/changing of Location Services by triggering a native dialog from within the app, avoiding the need for the user to leave your app to change location settings manually.
*
* @usage
* ```
* import { LocationAccuracy } from '@ionic-native/location-accuracy';
*
* constructor(private locationAccuracy: LocationAccuracy) { }
*
* ...
*
* this.locationAccuracy.canRequest().then((canRequest: boolean) => {
*
* if(canRequest) {
* // the accuracy option will be ignored by iOS
* this.locationAccuracy.request(this.locationAccuracy.REQUEST_PRIORITY_HIGH_ACCURACY).then(
* () => console.log('Request successful'),
* error => console.log('Error requesting location permissions', error)
* );
* }
*
* });
*
* ```
*/
@Plugin({
pluginName: 'LocationAccuracy',
plugin: 'cordova-plugin-request-location-accuracy',
pluginRef: 'cordova.plugins.locationAccuracy',
repo: 'https://github.com/dpa99c/cordova-plugin-request-location-accuracy'
})
@Injectable()
export class LocationAccuracy {
/**
* Indicates if you can request accurate location
* @returns {Promise<boolean>} Returns a promise that resovles with a boolean that indicates if you can request accurate location
*/
@Cordova()
canRequest(): Promise<boolean> { return; }
/**
* Indicates if a request is currently in progress
* @returns {Promise<boolean>} Returns a promise that resolves with a boolean that indicates if a request is currently in progress
*/
@Cordova()
isRequesting(): Promise<boolean> { return; }
/**
* Requests accurate location
* @param accuracy {number} Accuracy, from 0 to 4. You can use the static properties of this class that start with REQUEST_PRIORITY_
* @returns {Promise<any>} Returns a promise that resolves on success and rejects if an error occurred
*/
@Cordova({ callbackOrder: 'reverse' })
request(accuracy: number): Promise<any> { return; }
/**
* Convenience constant
* @type {number}
*/
REQUEST_PRIORITY_NO_POWER = 0;
/**
* Convenience constant
* @type {number}
*/
REQUEST_PRIORITY_LOW_POWER = 1;
/**
* Convenience constant
* @type {number}
*/
REQUEST_PRIORITY_BALANCED_POWER_ACCURACY = 2;
/**
* Convenience constant
* @type {number}
*/
REQUEST_PRIORITY_HIGH_ACCURACY = 3;
/**
* Convenience constant
* @type {number}
*/
SUCCESS_SETTINGS_SATISFIED = 0;
/**
* Convenience constant
* @type {number}
*/
SUCCESS_USER_AGREED = 1;
/**
* Convenience constant
* @type {number}
*/
ERROR_ALREADY_REQUESTING = -1;
/**
* Convenience constant
* @type {number}
*/
ERROR_INVALID_ACTION = 0;
/**
* Convenience constant
* @type {number}
*/
ERROR_INVALID_ACCURACY = 1;
/**
* Convenience constant
* @type {number}
*/
ERROR_EXCEPTION = 1;
/**
* Convenience constant
* @type {number}
*/
ERROR_CANNOT_CHANGE_ACCURACY = 3;
/**
* Convenience constant
* @type {number}
*/
ERROR_USER_DISAGREED = 4;
/**
* Convenience constant
* @type {number}
*/
ERROR_GOOGLE_API_CONNECTION_FAILED = 4;
}
src/@ionic-native/plugins/market/index.ts
+54
View File
@@ -0,0 +1,54 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Market
* @description
* Opens an app's page in the market place (Google Play, App Store)
*
* @usage
* ```
* import { Market } from '@ionic-native/market';
*
* constructor(private market: Market) { }
*
* ...
*
* this.market.open('your.package.name');
*
* ```
*/
@Plugin({
pluginName: 'Market',
plugin: 'cordova-plugin-market',
pluginRef: 'cordova.plugins.market',
repo: 'https://github.com/xmartlabs/cordova-plugin-market'
})
@Injectable()
export class Market {
/**
* Opens an app in Google Play / App Store
* @param appId {string} Package name
* @return {Promise<any>}
*/
@Cordova({
callbackStyle: 'object',
successName: 'success',
errorName: 'failure'
})
open(appId: string): Promise<any> { return; }
/**
* Search apps by keyword
* @param keyword {string} Keyword
* @return {Promise<any>}
*/
@Cordova({
callbackStyle: 'object',
successName: 'success',
errorName: 'failure',
platforms: ['Android']
})
search(keyword: string): Promise<any> { return; }
}
src/@ionic-native/plugins/media-capture/index.ts
+234
View File
@@ -0,0 +1,234 @@
import { Injectable } from '@angular/core';
import { Cordova, CordovaProperty, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
declare var navigator: any;
export interface MediaFile {
/**
* The name of the file, without path information.
*/
name: string;
/**
* The full path of the file, including the name.
*/
fullPath: string;
/**
* The file's mime type
*/
type: string;
/**
* The date and time when the file was last modified.
*/
lastModifiedDate: Date;
/**
* The size of the file, in bytes.
*/
size: number;
/**
* Retrieves the format information of the media file.
* @param {Function} successCallback
* @param {Function} errorCallback
*/
getFormatData(successCallback: (data: MediaFileData) => any, errorCallback?: (err: any) => any);
}
export interface MediaFileData {
/**
* The actual format of the audio and video content.
*/
codecs: string;
/**
* The average bitrate of the content. The value is zero for images.
*/
bitrate: number;
/**
* The height of the image or video in pixels. The value is zero for audio clips.
*/
height: number;
/**
* The width of the image or video in pixels. The value is zero for audio clips.
*/
width: number;
/**
* The length of the video or sound clip in seconds. The value is zero for images.
*/
duration: number;
}
export interface CaptureError {
code: string;
}
export interface CaptureAudioOptions {
/**
* Maximum number of audio clips. Defaults to 1.
* On iOS you can only record one file.
*/
limit?: number;
/**
* Maximum duration of an audio sound clip, in seconds. This does not work on Android devices.
*/
duration?: number;
}
export interface CaptureImageOptions {
/**
* Maximum number of images to capture. This limit is not supported on iOS, only one image will be taken per invocation.
*/
limit?: number;
}
export interface CaptureVideoOptions {
/**
* Maximum number of video clips to record. This value is ignored on iOS, only one video clip can be taken per invocation.
*/
limit?: number;
/**
* Maximum duration per video clip. This will be ignored on BlackBerry.
*/
duration?: number;
/**
* Quality of the video. This parameter can only be used with Android.
*/
quality?: number;
}
export interface ConfigurationData {
/**
* The ASCII-encoded lowercase string representing the media type.
*/
type: string;
/**
* The height of the image or video in pixels. The value is zero for sound clips.
*/
height: number;
/**
* The width of the image or video in pixels. The value is zero for sound clips.
*/
width: number;
}
/**
* @name Media Capture
* @description
* @usage
* ```typescript
* import { MediaCapture, MediaFile, CaptureError, CaptureImageOptions } from '@ionic-native/media-capture';
*
*
* constructor(private mediaCapture: MediaCapture) { }
*
* ...
*
*
* let options: CaptureImageOptions = { limit: 3 };
* this.mediaCapture.captureImage(options)
* .then(
* (data: MediaFile[]) => console.log(data),
* (err: CaptureError) => console.error(err)
* );
*
* ```
* @interfaces
* MediaFile
* MediaFileData
* CaptureError
* CaptureAudioOptions
* CaptureImageOptions
* CaptureVideoOptions
* ConfigurationData
*/
@Plugin({
pluginName: 'MediaCapture',
plugin: 'cordova-plugin-media-capture',
pluginRef: 'navigator.device.capture',
repo: 'https://github.com/apache/cordova-plugin-media-capture'
})
@Injectable()
export class MediaCapture {
/**
* The recording image sizes and formats supported by the device.
* @returns {ConfigurationData[]}
*/
@CordovaProperty
supportedImageModes: ConfigurationData[];
/**
* The audio recording formats supported by the device.
* @returns {ConfigurationData[]}
*/
@CordovaProperty
supportedAudioModes: ConfigurationData[];
/**
* The recording video resolutions and formats supported by the device.
* @returns {ConfigurationData[]}
*/
@CordovaProperty
supportedVideoModes: ConfigurationData[];
/**
* Start the audio recorder application and return information about captured audio clip files.
* @param options
* @returns {Promise<MediaFile[]>}
*/
@Cordova({
callbackOrder: 'reverse'
})
captureAudio(options?: CaptureAudioOptions): Promise<MediaFile[] | CaptureError> {
return;
}
/**
* Start the camera application and return information about captured image files.
* @param options
* @returns {Promise<MediaFile[]>}
*/
@Cordova({
callbackOrder: 'reverse'
})
captureImage(options?: CaptureImageOptions): Promise<MediaFile[] | CaptureError> {
return;
}
/**
* Start the video recorder application and return information about captured video clip files.
* @param options
* @returns {Promise<MediaFile[]>}
*/
@Cordova({
callbackOrder: 'reverse'
})
captureVideo(options?: CaptureVideoOptions): Promise<MediaFile[] | CaptureError> {
return;
}
/**
* is fired if the capture call is successful
* @returns {Observable<MediaFile[]>}
*/
@Cordova({
eventObservable: true,
event: 'pendingcaptureresult'
})
onPendingCaptureResult(): Observable<MediaFile[]> {
return;
}
/**
* is fired if the capture call is unsuccessful
* @returns {Observable<CaptureError>}
*/
@Cordova({
eventObservable: true,
event: 'pendingcaptureerror'
})
onPendingCaptureError(): Observable<CaptureError> {
return;
}
}
src/@ionic-native/plugins/media/index.ts
+264
View File
@@ -0,0 +1,264 @@
import { Injectable } from '@angular/core';
import { CordovaInstance, Plugin, CordovaCheck } from '@ionic-native/core';
declare var Media: any;
/**
* @hidden
*/
export class MediaObject {
/**
* Open a media file
* @param src {string} A URI containing the audio content.
* @param onStatusUpdate {Function} A callback function to be invoked when the status of the file changes
*/
constructor(private _objectInstnace: any) {}
/**
* Get the current amplitude of the current recording.
* @returns {Promise<any>} Returns a promise with the amplitude of the current recording
*/
@CordovaInstance()
getCurrentAmplitude(): Promise<any> { return; }
/**
* Get the current position within an audio file. Also updates the Media object's position parameter.
* @returns {Promise<any>} Returns a promise with the position of the current recording
*/
@CordovaInstance()
getCurrentPosition(): Promise<any> { return; }
/**
* Get the duration of an audio file in seconds. If the duration is unknown, it returns a value of -1.
* @returns {number} Returns a promise with the duration of the current recording
*/
@CordovaInstance({
sync: true
})
getDuration(): number { return; }
/**
* Starts or resumes playing an audio file.
*/
@CordovaInstance({
sync: true
})
play(iosOptions?: {
numberOfLoops?: number,
playAudioWhenScreenIsLocked?: boolean
}): void { }
/**
* Pauses playing an audio file.
*/
@CordovaInstance({
sync: true
})
pause(): void { }
/**
* Releases the underlying operating system's audio resources. This is particularly important for Android, since there are a finite amount of OpenCore instances for media playback. Applications should call the release function for any Media resource that is no longer needed.
*/
@CordovaInstance({
sync: true
})
release(): void { }
/**
* Sets the current position within an audio file.
* @param {number} milliseconds The time position you want to set for the current audio file
*/
@CordovaInstance({
sync: true
})
seekTo(milliseconds: number): void { }
/**
* Set the volume for an audio file.
* @param volume {number} The volume to set for playback. The value must be within the range of 0.0 to 1.0.
*/
@CordovaInstance({
sync: true
})
setVolume(volume: number): void { }
/**
* Starts recording an audio file.
*/
@CordovaInstance({
sync: true
})
startRecord(): void { }
/**
* Stops recording
*/
@CordovaInstance({
sync: true
})
stopRecord(): void { }
/**
* Pauses recording
*/
@CordovaInstance({
sync: true
})
pauseRecord(): void { }
/**
* Resumes recording
*/
@CordovaInstance({
sync: true
})
resumeRecord(): void { }
/**
* Stops playing an audio file.
*/
@CordovaInstance({
sync: true
})
stop(): void { }
}
/**
* @name MediaPlugin
* @description
* @usage
* ```typescript
* import { MediaPlugin, MediaObject } from '@ionic-native/media';
*
*
* constructor(private media: MediaPlugin) { }
*
*
* ...
*
*
* // Create a MediaPlugin instance. Expects path to file or url as argument
* // We can optionally pass a second argument to track the status of the media
*
* const onStatusUpdate = (status) => console.log(status);
*
* this.media.create('path/to/file.mp3', onStatusUpdate)
* .then((file: MediaObject) => {
*
* // play the file
* file.play();
*
* // pause the file
* file.pause();
*
* // get current playback position
* file.getCurrentPosition().then((position) => {
* console.log(position);
* });
*
* // get file duration
* file.getDuration().then((duration) => {
* console.log(position);
* });
*
* // skip to 10 seconds (expects int value in ms)
* file.seekTo(10000);
*
* // stop playing the file
* file.stop();
*
* // release the native audio resource
* // Platform Quirks:
* // iOS simply create a new instance and the old one will be overwritten
* // Android you must call release() to destroy instances of media when you are done
* file.release();
*
* })
* .catch(e => console.log('Error opening media file', e));
*
*
* // Recording to a file
* this.media.create('path/to/file.mp3')
* .then((file: MedieObject) => {
*
* file.startRecord();
*
* file.stopRecord();
*
* });
*
* ```
* @classes
* MediaObject
*/
@Plugin({
pluginName: 'MediaPlugin',
repo: 'https://github.com/apache/cordova-plugin-media',
plugin: 'cordova-plugin-media',
pluginRef: 'Media'
})
@Injectable()
class MediaPlugin {
// Constants
/**
* @hidden
*/
MEDIA_NONE: number = 0;
/**
* @hidden
*/
MEDIA_STARTING: number = 1;
/**
* @hidden
*/
MEDIA_RUNNING: number = 2;
/**
* @hidden
*/
MEDIA_PAUSED: number = 3;
/**
* @hidden
*/
MEDIA_STOPPED: number = 4;
// error codes
/**
* @hidden
*/
MEDIA_ERR_ABORTED: number = 1;
/**
* @hidden
*/
MEDIA_ERR_NETWORK: number = 2;
/**
* @hidden
*/
MEDIA_ERR_DECODE: number = 3;
/**
* @hidden
*/
MEDIA_ERR_NONE_SUPPORTED: number = 4;
/**
* Open a media file
* @param src {string} A URI containing the audio content.
* @param onStatusUpdate {Function} A callback function to be invoked when the status of the file changes
* @return {Promise<MediaObject>}
*/
@CordovaCheck()
create(src: string, onStatusUpdate?: Function): Promise<MediaObject> {
return new Promise<MediaObject>((resolve, reject) => {
// Creates a new media object
// Resolves with the media object
// or rejects with the error
const instance = new Media(src, () => resolve(new Media(instance)), reject, onStatusUpdate);
});
}
}
src/@ionic-native/plugins/mixpanel/index.ts
+160
View File
@@ -0,0 +1,160 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
declare var mixpanel: any;
/**
* @name Mixpanel
* @description
* Cordova Plugin that wraps Mixpanel SDK for Android and iOS
*
* @usage
* ```
* import { Mixpanel, MixpanelPeople } from '@ionic-native/mixpanel';
*
* constructor(private mixpanel: Mixpanel, private mixpanelPeople: MixpanelPeople) { }
*
* ...
*
* this.mixpanel.init(token)
* .then(onSuccess)
* .catch(onError);
*
* ```
* @classes
* MixpanelPeople
*/
@Plugin({
pluginName: 'Mixpanel',
plugin: 'cordova-plugin-mixpanel',
pluginRef: 'mixpanel',
repo: 'https://github.com/samzilverberg/cordova-mixpanel-plugin'
})
@Injectable()
export class Mixpanel {
/**
*
* @param aliasId {string}
* @param originalId {string}
* @returns {Promise<any>}
*/
@Cordova()
alias(aliasId: string, originalId: string): Promise<any> { return; }
/**
*
* @returns {Promise<any>}
*/
@Cordova()
distinctId(): Promise<any> { return; }
/**
* @returns {Promise<any>}
*/
@Cordova()
flush(): Promise<any> { return; }
/**
*
* @param distinctId {string}
* @returns {Promise<any>}
*/
@Cordova()
identify(distinctId: string): Promise<any> { return; }
/**
*
* @param token {string}
* @returns {Promise<any>}
*/
@Cordova()
init(token: string): Promise<any> { return; }
/**
*
* @param superProperties {any}
* @returns {Promise<any>}
*/
@Cordova()
registerSuperProperties(superProperties: any): Promise<any> { return; }
/**
*
* @returns {Promise<any>}
*/
@Cordova()
reset(): Promise<any> { return; }
/**
*
* @param eventName {string}
* @param eventProperties {any} optional
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 2,
errorIndex: 3
})
track(eventName: string, eventProperties?: any): Promise<any> { return; }
/**
*
* @returns {Promise<any>}
*/
@Cordova()
showSurvey(): Promise<any> { return; }
}
/**
* @hidden
*/
@Injectable()
@Plugin({
plugin: 'cordova-plugin-mixpanel',
pluginRef: 'mixpanel.people',
pluginName: 'Mixpanel'
})
export class MixpanelPeople {
/**
*
* @param distinctId {string}
* @return {Promise<any>}
*/
@Cordova()
identify(distinctId: string): Promise<any> { return; }
/**
*
* @param peopleProperties {string}
* @return {Promise<any>}
*/
@Cordova()
increment(peopleProperties: any): Promise<any> { return; }
/**
*
* @param pushId
* @return {Promise<any>}
*/
@Cordova()
setPushId(pushId: string): Promise<any> { return; }
/**
*
* @param peopleProperties
* @return {Promise<any>}
*/
@Cordova()
set(peopleProperties: any): Promise<any> { return; }
/**
*
* @param peopleProperties
* @return {Promise<any>}
*/
@Cordova()
setOnce(peopleProperties: any): Promise<any> { return; }
}
src/@ionic-native/plugins/music-controls/index.ts
+155
View File
@@ -0,0 +1,155 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export interface MusicControlsOptions {
track: string;
artist: string;
cover: string;
isPlaying: boolean;
dismissable: boolean;
hasPrev: boolean;
hasNext: boolean;
hasClose: boolean;
album: string;
duration: number;
elapsed: number;
ticker: string;
}
/**
* @name Music Controls
* @description
* Music controls for Cordova applications.
* Display a 'media' notification with play/pause, previous, next buttons, allowing the user to control the play.
* Handle also headset event (plug, unplug, headset button).
*
* @usage
* ```
* import { MusicControls } from '@ionic-native/music-controls';
*
* constructor(private musicControls: MusicControls) { }
*
* ...
*
* this.musicControls.create({
* track : 'Time is Running Out', // optional, default : ''
* artist : 'Muse', // optional, default : ''
* cover : 'albums/absolution.jpg', // optional, default : nothing
* // cover can be a local path (use fullpath 'file:///storage/emulated/...', or only 'my_image.jpg' if my_image.jpg is in the www folder of your app)
* // or a remote url ('http://...', 'https://...', 'ftp://...')
* isPlaying : true, // optional, default : true
* dismissable : true, // optional, default : false
*
* // hide previous/next/close buttons:
* hasPrev : false, // show previous button, optional, default: true
* hasNext : false, // show next button, optional, default: true
* hasClose : true, // show close button, optional, default: false
*
* // iOS only, optional
* album : 'Absolution' // optional, default: ''
* duration : 60, // optional, default: 0
* elapsed : 10, // optional, default: 0
*
* // Android only, optional
* // text displayed in the status bar when the notification (and the ticker) are updated
* ticker : 'Now playing "Time is Running Out"'
* });
*
* this.musicControls.subscribe().subscribe(action => {
*
* switch(action) {
* case 'music-controls-next':
* // Do something
* break;
* case 'music-controls-previous':
* // Do something
* break;
* case 'music-controls-pause':
* // Do something
* break;
* case 'music-controls-play':
* // Do something
* break;
* case 'music-controls-destroy':
* // Do something
* break;
*
* // Headset events (Android only)
* case 'music-controls-media-button' :
* // Do something
* break;
* case 'music-controls-headset-unplugged':
* // Do something
* break;
* case 'music-controls-headset-plugged':
* // Do something
* break;
* default:
* break;
* }
*
* });
*
* this.musicControls.listen(); // activates the observable above
*
* this.musicControls.updateIsPlaying(true);
*
*
* ```
* @interfaces
* MusicControlsOptions
*/
@Plugin({
pluginName: 'MusicControls',
plugin: 'cordova-plugin-music-controls',
pluginRef: 'MusicControls',
repo: 'https://github.com/homerours/cordova-music-controls-plugin'
})
@Injectable()
export class MusicControls {
/**
* Create the media controls
* @param options {MusicControlsOptions}
* @returns {Promise<any>}
*/
@Cordova()
create(options: MusicControlsOptions): Promise<any> {return; }
/**
* Destroy the media controller
* @returns {Promise<any>}
*/
@Cordova()
destroy(): Promise<any> {return; }
/**
* Subscribe to the events of the media controller
* @returns {Observable<any>}
*/
@Cordova({
observable: true
})
subscribe(): Observable<any> {return; }
/**
* Start listening for events, this enables the Observable from the subscribe method
*/
@Cordova({sync: true})
listen(): void {}
/**
* Toggle play/pause:
* @param isPlaying {boolean}
*/
@Cordova()
updateIsPlaying(isPlaying: boolean): void {}
/**
* Toggle dismissable:
* @param dismissable {boolean}
*/
@Cordova()
updateDismissable(dismissable: boolean): void {}
}
src/@ionic-native/plugins/native-audio/index.ts
+106
View File
@@ -0,0 +1,106 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Native Audio
* @description Native Audio Playback
* @usage
* ```typescript
* import { NativeAudio } from '@ionic-native/native-audio';
*
* constructor(private nativeAudio: NativeAudio) { }
*
* ...
*
* this.nativeAudio.preloadSimple('uniqueId1', 'path/to/file.mp3').then(onSuccess, onError);
* this.nativeAudio.preloadComplex('uniqueId2', 'path/to/file2.mp3', 1, 1, 0).then(onSuccess, onError);
*
* this.nativeAudio.play('uniqueId1').then(onSuccess, onError);
*
* // can optionally pass a callback to be called when the file is done playing
* this.nativeAudio.play('uniqueId1', () => console.log('uniqueId1 is done playing'));
*
* this.nativeAudio.loop('uniqueId2').then(onSuccess, onError);
*
* this.nativeAudio.setVolumeForComplexAsset('uniqueId2', 0.6).then(onSuccess,onError);
*
* this.nativeAudio.stop('uniqueId1').then(onSuccess,onError);
*
* this.nativeAudio.unload('uniqueId1').then(onSuccess,onError);
*
* ```
*/
@Plugin({
pluginName: 'NativeAudio',
plugin: 'cordova-plugin-nativeaudio',
pluginRef: 'plugins.NativeAudio',
repo: 'https://github.com/floatinghotpot/cordova-plugin-nativeaudio'
})
@Injectable()
export class NativeAudio {
/**
* Loads an audio file into memory. Optimized for short clips / single shots (up to five seconds). Cannot be stopped / looped.
* @param id {string} unique ID for the audio file
* @param assetPath {string} the relative path or absolute URL (inluding http://) to the audio asset.
* @returns {Promise<any>}
*/
@Cordova()
preloadSimple(id: string, assetPath: string): Promise<any> {return; }
/**
* Loads an audio file into memory. Optimized for background music / ambient sound. Uses highlevel native APIs with a larger footprint. (iOS: AVAudioPlayer). Can be stopped / looped and used with multiple voices. Can be faded in and out using the delay parameter.
* @param id {string} unique ID for the audio file
* @param assetPath {string} the relative path or absolute URL (inluding http://) to the audio asset.
* @param volume {number} the volume of the preloaded sound (0.1 to 1.0)
* @param voices {number} the number of multichannel voices available
* @param delay {number}
* @returns {Promise<any>}
*/
@Cordova()
preloadComplex(id: string, assetPath: string, volume: number, voices: number, delay: number): Promise<any> {return; }
/**
* Plays an audio asset
* @param id {string} unique ID for the audio file
* @param completeCallback {Function} optional. Callback to be invoked when audio is done playing
* @returns {Promise<any>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
play(id: string, completeCallback?: Function): Promise<any> {return; }
/**
* Stops playing an audio
* @param id {string} unique ID for the audio file
* @returns {Promise<any>}
*/
@Cordova()
stop(id: string): Promise<any> {return; }
/**
* Loops an audio asset infinitely, this only works for complex assets
* @param id {string} unique ID for the audio file
* @return {Promise<any>}
*/
@Cordova()
loop(id: string): Promise<any> {return; }
/**
* Unloads an audio file from memory
* @param id {string} unique ID for the audio file
* @returns {Promise<any>}
*/
@Cordova()
unload(id: string): Promise<any> {return; }
/**
* Changes the volume for preloaded complex assets.
* @param id {string} unique ID for the audio file
* @param volume {number} the volume of the audio asset (0.1 to 1.0)
* @returns {Promise<any>}
*/
@Cordova()
setVolumeForComplexAsset(id: string, volume: number): Promise<any> {return; }
}
src/@ionic-native/plugins/native-geocoder/index.ts
+104
View File
@@ -0,0 +1,104 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @beta
* @name Native Geocoder
* @description
* Cordova plugin for native forward and reverse geocoding
*
* @usage
* ```typescript
* import { NativeGeocoder, NativeGeocoderReverseResult, NativeGeocoderForwardResult } from '@ionic-native/native-geocoder';
*
* constructor(private nativeGeocoder: NativeGeocoder) { }
*
* ...
*
* this.nativeGeocoder.reverseGeocode(52.5072095, 13.1452818)
* .then((result: NativeGeocoderReverseResult) => console.log("The address is " + result.street + " in " + result.countryCode))
* .catch((error: any) => console.log(error));
*
* this.nativeGeocoder.forwardGeocode("Berlin")
* .then((coordinates: NativeGeocoderForwardResult) => console.log("The coordinates are latitude=" + coordinates.latitude + " and longitude=" + coordinates.longitude))
* .catch((error: any) => console.log(error));
* ```
* @interfaces
* NativeGeocoderReverseResult
* NativeGeocoderForwardResult
*/
@Plugin({
pluginName: 'NativeGeocoder',
plugin: 'cordova-plugin-nativegeocoder',
pluginRef: 'nativegeocoder',
repo: 'https://github.com/sebastianbaar/cordova-plugin-nativegeocoder',
platforms: ['iOS', 'Android']
})
@Injectable()
export class NativeGeocoder {
/**
* Reverse geocode a given latitude and longitude to find location address
* @param latitude {number} The latitude
* @param longitude {number} The longitude
* @return {Promise<any>}
*/
@Cordova({
callbackOrder: 'reverse'
})
reverseGeocode(latitude: number, longitude: number): Promise<NativeGeocoderReverseResult> { return; }
/**
* Forward geocode a given address to find coordinates
* @param addressString {string} The address to be geocoded
* @return {Promise<any>}
*/
@Cordova({
callbackOrder: 'reverse'
})
forwardGeocode(addressString: string): Promise<NativeGeocoderForwardResult> { return; }
}
/**
* Encapsulates format information about a reverse geocoding result.
*/
export interface NativeGeocoderReverseResult {
/**
* The street.
*/
street: string;
/**
* The house number.
*/
houseNumber: string;
/**
* The postal code.
*/
postalCode: string;
/**
* The city.
*/
city: string;
/**
* The country name.
*/
countryName: string;
/**
* The country code.
*/
countryCode: string;
}
/**
* Encapsulates format information about a forward geocoding result.
*/
export interface NativeGeocoderForwardResult {
/**
* The latitude.
*/
latitude: string;
/**
* The longitude.
*/
longitude: string;
}
src/@ionic-native/plugins/native-page-transitions/index.ts
+102
View File
@@ -0,0 +1,102 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
export interface NativeTransitionOptions {
direction?: string;
duration?: number;
slowdownfactor?: number;
slidePixels?: number;
iosdelay?: number;
androiddelay?: number;
winphonedelay?: number;
fixedPixelsTop?: number;
fixedPixelsBottom?: number;
action?: string;
origin?: string;
href?: string;
}
/**
* @name Native Page Transitions
* @description
* The Native Page Transitions plugin uses native hardware acceleration to animate your transitions between views. You have complete control over the type of transition, the duration, and direction.
*
* @usage
* ```
* import { NativePageTransitions, NativeTransitionOptions } from '@ionic-native/native-page-transitions';
*
* constructor(private nativePageTransitions: NativePageTransitions) { }
*
* ...
*
* let options: NativeTransitionOptions = {
* direction: 'up',
* duration: 500,
* slowdownfactor: 3,
* slidePixels: 20,
* iosdelay: 100,
* androiddelay: 150,
* winphonedelay: 250,
* fixedPixelsTop: 0,
* fixedPixelsBottom: 60
* };
*
* this.nativePageTransitions.slide(options)
* .then(onSuccess)
* .catch(onError);
*
* ```
*/
@Plugin({
pluginName: 'NativePageTransitions',
plugin: 'com.telerik.plugins.nativepagetransitions',
pluginRef: 'plugins.nativepagetransitions',
repo: 'https://github.com/Telerik-Verified-Plugins/NativePageTransitions',
platforms: ['iOS', 'Android', 'Windows Phone']
})
@Injectable()
export class NativePageTransitions {
/**
* Perform a slide animation
* @param options {NativeTransitionOptions} Options for the transition
* @returns {Promise<any>}
*/
@Cordova()
slide(options: NativeTransitionOptions): Promise<any> { return; }
/**
* Perform a flip animation
* @param options {NativeTransitionOptions} Options for the transition
* @returns {Promise<any>}
*/
@Cordova()
flip(options: NativeTransitionOptions): Promise<any> { return; }
/**
* Perform a fade animation
* @param options {NativeTransitionOptions} Options for the transition
* @returns {Promise<any>}
*/
@Cordova({platforms: ['iOS', 'Android']})
fade(options: NativeTransitionOptions): Promise<any> { return; }
/**
* Perform a slide animation
* @param options {NativeTransitionOptions} Options for the transition
* @returns {Promise<any>}
*/
@Cordova({platforms: ['iOS', 'Android']})
drawer(options: NativeTransitionOptions): Promise<any> { return; }
/**
* Perform a slide animation
* @param options {NativeTransitionOptions} Options for the transition
* @returns {Promise<any>}
*/
@Cordova({platforms: ['iOS']})
curl(options: NativeTransitionOptions): Promise<any> { return; }
}
src/@ionic-native/plugins/native-storage/index.ts
+70
View File
@@ -0,0 +1,70 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Native Storage
* @description Native storage of variables in Android and iOS
*
* @usage
* ```typescript
* import { NativeStorage } from '@ionic-native/native-storage';
*
* constructor(private nativeStorage: NativeStorage) { }
*
* ...
*
* this.nativeStorage.setItem('myitem', {property: 'value', anotherProperty: 'anotherValue'})
* .then(
* () => console.log('Stored item!'),
* error => console.error('Error storing item', error)
* );
*
* this.nativeStorage.getItem('myitem')
* .then(
* data => console.log(data),
* error => console.error(error)
* );
* ```
*/
@Plugin({
pluginName: 'NativeStorage',
plugin: 'cordova-plugin-nativestorage',
pluginRef: 'NativeStorage',
repo: 'https://github.com/TheCocoaProject/cordova-plugin-nativestorage'
})
@Injectable()
export class NativeStorage {
/**
* Stores a value
* @param reference {string}
* @param value
* @returns {Promise<any>}
*/
@Cordova()
setItem(reference: string, value: any): Promise<any> {return; }
/**
* Gets a stored item
* @param reference {string}
* @returns {Promise<any>}
*/
@Cordova()
getItem(reference: string): Promise<any> {return; }
/**
* Removes a single stored item
* @param reference {string}
* @returns {Promise<any>}
*/
@Cordova()
remove(reference: string): Promise<any> {return; }
/**
* Removes all stored values.
* @returns {Promise<any>}
*/
@Cordova()
clear(): Promise<any> {return; }
}
src/@ionic-native/plugins/navigation-bar/index.ts
+56
View File
@@ -0,0 +1,56 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @beta
* @name Navigation Bar
* @description
* The NavigationBar plugin can you to hide and auto hide the android navigation bar.
*
* @usage
* ```typescript
* import { NavigationBar } from '@ionic-native/navigation-bar';
*
* constructor(private navigationBar: NavigationBar) { }
*
* ...
*
* let autoHide: boolean = true;
* this.navigationBar.hide(autoHide);
* ```
*/
@Plugin({
pluginName: 'NavigationBar',
plugin: 'cordova-plugin-navigationbar',
pluginRef: 'navigationbar',
repo: 'https://github.com/cranberrygame/cordova-plugin-navigationbar',
platforms: ['Android']
})
@Injectable()
export class NavigationBar {
/**
* hide automatically (or not) the navigation bar.
* @param autohide {boolean}  
* @return {Promise<any>}
*/
@Cordova({
callbackStyle: 'object',
successName: 'success',
errorName: 'failure'
})
setUp(autohide?: boolean): Promise<any> { return; }
/**
* Hide the navigation bar. 
* @return {Promise<any>}
*/
@Cordova({
callbackStyle: 'object',
successName: 'success',
errorName: 'failure'
})
hideNavigationBar(): Promise<any> { return; }
}
src/@ionic-native/plugins/network/index.ts
+108
View File
@@ -0,0 +1,108 @@
import { Injectable } from '@angular/core';
import {Cordova, CordovaProperty, Plugin, CordovaFunctionOverride} from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
declare var navigator: any;
/**
* @name Network
* @description
* Requires Cordova plugin: cordova-plugin-network-information. For more info, please see the [Network plugin docs](https://github.com/apache/cordova-plugin-network-information).
*
* @usage
* ```typescript
* import { Network } from '@ionic-native/network';
*
* constructor(private network: Network) { }
*
* ...
*
* // watch network for a disconnect
* let disconnectSubscription = this.network.onDisconnect().subscribe(() => {
* console.log('network was disconnected :-(');
* });
*
* // stop disconnect watch
* disconnectSubscription.unsubscribe();
*
*
* // watch network for a connection
* let connectSubscription = this.network.onConnect().subscribe(() => {
* console.log('network connected!');

* // We just got a connection but we need to wait briefly
*
 // before we determine the connection type. Might need to wait

* // prior to doing any api requests as well.
* setTimeout(() => {
* if (Network.type === 'wifi') {
* console.log('we got a wifi connection, woohoo!');
* }
* }, 3000);
* });
*
* // stop connect watch
* connectSubscription.unsubscribe();
*
* ```
* @advanced
* The `type` property will return one of the following connection types: `unknown`, `ethernet`, `wifi`, `2g`, `3g`, `4g`, `cellular`, `none`
*/
@Plugin({
pluginName: 'Network',
plugin: 'cordova-plugin-network-information',
repo: 'https://github.com/apache/cordova-plugin-network-information',
platforms: ['Amazon Fire OS', 'iOS', 'Android', 'BlackBerry 10', 'Windows Phone 7', 'Windows Phone 8', 'Windows', 'Firefox OS', 'Browser'],
pluginRef: 'navigator.connection'
})
@Injectable()
export class Network {
/**
* Connection type
* @return {string}
*/
@CordovaProperty
type: string;
/**
* Downlink Max Speed
* @return {string}
*/
@CordovaProperty
downlinkMax: string;
/**
* Returns an observable to watch connection changes
* @return {Observable<any>}
*/
@CordovaFunctionOverride()
onchange(): Observable<any> { return; }
/**
* Returns an observable to watch connection type changes
* @return {Observable<any>}
*/
@CordovaFunctionOverride()
ontypechange(): Observable<any> { return; }
/**
* Get notified when the device goes offline
* @returns {Observable<any>} Returns an observable.
*/
@Cordova({
eventObservable: true,
event: 'offline'
})
onDisconnect(): Observable<any> { return; }
/**
* Get notified when the device goes online
* @returns {Observable<any>} Returns an observable.
*/
@Cordova({
eventObservable: true,
event: 'online'
})
onConnect(): Observable<any> { return; }
}
src/@ionic-native/plugins/nfc/index.ts
+206
View File
@@ -0,0 +1,206 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
declare let window: any;
/**
* @name NFC
* @description
* The NFC plugin allows you to read and write NFC tags. You can also beam to, and receive from, other NFC enabled devices.
*
* Use to
* - read data from NFC tags
* - write data to NFC tags
* - send data to other NFC enabled devices
* - receive data from NFC devices
*
* This plugin uses NDEF (NFC Data Exchange Format) for maximum compatibilty between NFC devices, tag types, and operating systems.
*
* @usage
* ```
* import { NFC, Ndef } from '@ionic-native/nfc';
*
* constructor(private nfc: NFC, private ndef: Ndef) { }
*
* ...
*
* let message = this.ndef.textRecord('Hello world');
* this.nfc.share([message]).then(onSuccess).catch(onError);
*
* ```
*/
@Plugin({
pluginName: 'NFC',
plugin: 'phonegap-nfc',
pluginRef: 'nfc',
repo: 'https://github.com/chariotsolutions/phonegap-nfc'
})
@Injectable()
export class NFC {
/**
* Registers an event listener for any NDEF tag.
* @param onSuccess
* @param onFailure
* @returns {Observable<any>}
*/
@Cordova({
observable: true,
successIndex: 0,
errorIndex: 3,
clearFunction: 'removeNdefListener',
clearWithArgs: true
})
addNdefListener(onSuccess?: Function, onFailure?: Function): Observable<any> {return; }
/**
* Registers an event listener for tags matching any tag type.
* @param onSuccess
* @param onFailure
* @returns {Observable<any>}
*/
@Cordova({
observable: true,
successIndex: 0,
errorIndex: 3,
clearFunction: 'removeTagDiscoveredListener',
clearWithArgs: true
})
addTagDiscoveredListener(onSuccess?: Function, onFailure?: Function): Observable<any> {return; }
/**
* Registers an event listener for NDEF tags matching a specified MIME type.
* @param mimeType
* @param onSuccess
* @param onFailure
* @returns {Observable<any>}
*/
@Cordova({
observable: true,
successIndex: 1,
errorIndex: 4,
clearFunction: 'removeMimeTypeListener',
clearWithArgs: true
})
addMimeTypeListener(mimeType: string, onSuccess?: Function, onFailure?: Function): Observable<any> {return; }
/**
* Registers an event listener for formatable NDEF tags.
* @param onSuccess
* @param onFailure
* @returns {Observable<any>}
*/
@Cordova({
observable: true,
successIndex: 0,
errorIndex: 3
})
addNdefFormatableListener(onSuccess?: Function, onFailure?: Function): Observable<any> {return; }
/**
* Qrites an NdefMessage to a NFC tag.
* @param message {any[]}
* @returns {Promise<any>}
*/
@Cordova()
write(message: any[]): Promise<any> {return; }
/**
* Makes a NFC tag read only. **Warning** this is permanent.
* @returns {Promise<any>}
*/
@Cordova()
makeReadyOnly(): Promise<any> {return; }
/**
* Shares an NDEF Message via peer-to-peer.
* @param message An array of NDEF Records.
* @returns {Promise<any>}
*/
@Cordova()
share(message: any[]): Promise<any> {return; }
/**
* Stop sharing NDEF data via peer-to-peer.
* @returns {Promise<any>}
*/
@Cordova()
unshare(): Promise<any> {return; }
/**
* Erase a NDEF tag
*/
@Cordova()
erase(): Promise<any> {return; }
/**
* Send a file to another device via NFC handover.
* @param uris A URI as a String, or an array of URIs.
* @returns {Promise<any>}
*/
@Cordova()
handover(uris: string[]): Promise<any> {return; }
/**
* Stop sharing NDEF data via NFC handover.
* @returns {Promise<any>}
*/
@Cordova()
stopHandover(): Promise<any> {return; }
/**
* Show the NFC settings on the device.
* @returns {Promise<any>}
*/
@Cordova()
showSettings(): Promise<any> {return; }
/**
* Check if NFC is available and enabled on this device.
* @returns {Promise<any>}
*/
@Cordova()
enabled(): Promise<any> {return; }
/**
* Convert bytes to string
* @param bytes {number[]}
* @returns {string}
*/
@Cordova({ sync: true })
bytesToString(bytes: number[]): string {return; }
/**
* Convert string to bytes
* @param str {string}
* @returns {number[]}
*/
@Cordova({ sync: true })
stringToBytes(str: string): number[] {return; };
/**
* Convert bytes to hex string
* @param bytes {number[]}
* @returns {string}
*/
@Cordova({ sync: true })
bytesToHexString(bytes: number[]): string {return; };
}
/**
* @hidden
*/
@Injectable()
@Plugin({
pluginName: 'NFC',
plugin: 'phonegap-nfc',
pluginRef: 'ndef'
})
export class Ndef {
@Cordova({ sync: true })
uriRecord(uri: string): any { return; }
@Cordova({ sync: true })
textRecord(text: string): any { return; }
@Cordova({ sync: true })
mimeMediaRecord(mimeType: string, payload: string): any { return; }
@Cordova({ sync: true })
androidApplicationRecord(packageName: string): any { return; }
}
src/@ionic-native/plugins/onesignal/index.ts
+521
View File
@@ -0,0 +1,521 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
export interface OSNotification {
/**
* Was app in focus.
*/
isAppInFocus: boolean;
/**
* Was notification shown to the user. Will be false for silent notifications.
*/
shown: boolean;
/**
* **ANDROID** - Android Notification assigned to the notification. Can be used to cancel or replace the notification.
*/
androidNotificationId?: number;
/**
* Payload received from OneSignal.
*/
payload: OSNotificationPayload;
/**
* How the notification was displayed to the user. Can be set to `Notification`, `InAppAlert`, or `None` if it was not displayed.
*/
displayType: OSDisplayType;
/**
* **ANDROID** - Notification is a summary notification for a group this will contain all notification payloads it was created from.
*/
groupedNotifications?: OSNotificationPayload[];
app_id?: string;
contents: any;
headings?: any;
isIos?: boolean;
isAndroid?: boolean;
isWP?: boolean;
isWP_WNS?: boolean;
isAdm?: boolean;
isChrome?: boolean;
isChromeWeb?: boolean;
isSafari?: boolean;
isAnyWeb?: boolean;
included_segments?: string[];
excluded_segments?: string[];
include_player_ids?: string[];
include_ios_tokens?: string[];
include_android_reg_ids?: string[];
include_wp_uris?: string[];
include_wp_wns_uris?: string[];
include_amazon_reg_ids?: string[];
include_chrome_reg_ids?: string[];
include_chrome_web_reg_ids?: string[];
app_ids?: string[];
tags?: any[];
ios_badgeType?: string;
ios_badgeCount?: number;
ios_sound?: string;
android_sound?: string;
adm_sound?: string;
wp_sound?: string;
wp_wns_sound?: string;
data?: any;
buttons?: any;
small_icon?: string;
large_icon?: string;
big_picture?: string;
adm_small_icon?: string;
adm_large_icon?: string;
adm_big_picture?: string;
chrome_icon?: string;
chrome_big_picture?: string;
chrome_web_icon?: string;
firefox_icon?: string;
url?: string;
send_after?: string;
delayed_option?: string;
delivery_time_of_day?: string;
android_led_color?: string;
android_accent_color?: string;
android_visibility?: number;
content_available?: boolean;
amazon_background_data?: boolean;
template_id?: string;
android_group?: string;
android_group_message?: any;
adm_group?: string;
adm_group_message?: any;
ttl?: number;
priority?: number;
ios_category?: string;
}
/**
* **ANDROID** - Privacy setting for how the notification should be shown on the lockscreen of Android 5+ devices.
*/
export enum OSLockScreenVisibility {
/**
* Fully visible (default)
*/
Public = 1,
/**
* Contents are hidden
*/
Private = 0,
/**
* Not shown
*/
Secret = -1
}
/**
* How the notification was displayed to the user. Part of OSNotification. See inFocusDisplaying for more information on how this is used.
*/
export enum OSDisplayType {
/**
* notification is silent, or inFocusDisplaying is disabled.
*/
None = 0,
/**
* (**DEFAULT**) - native alert dialog display.
*/
InAppAlert = 1,
/**
* native notification display.
*/
Notification = 2
}
/**
* Contents and settings of the notification the user received.
*/
export interface OSNotificationPayload {
/**
* OneSignal notification UUID.
*/
notificationID: string;
/**
* Title of the notification.
*/
title: string;
/**
* Body of the notification.
*/
body: string;
/**
* Custom additional data that was sent with the notification. Set on the dashboard under Options > Additional Data
* or with the 'data' field on the REST API.
*/
additionalData?: any;
/**
* **ANDROID** - Small icon resource name set on the notification.
*/
smallIcon?: string;
/**
* **ANDROID** - Large icon set on the notification.
*/
largeIcon?: string;
/**
* **ANDROID** - Big picture image set on the notification.
*/
bigPicture?: string;
/**
* **ANDROID** - Accent color shown around small notification icon on Android 5+ devices. ARGB format.
*/
smallIconAccentColor?: string;
/**
* URL to open when opening the notification.
*/
launchUrl?: string;
/**
* Sound resource to play when the notification is shown.
*/
sound: string;
/**
* **ANDROID** - Devices that have a notification LED will blink in this color. ARGB format.
*/
ledColor?: string;
lockScreenVisibility?: OSLockScreenVisibility;
/**
* **ANDROID** - Notifications with this same key will be grouped together as a single summary notification.
*/
groupKey?: string;
/**
* **ANDROID** - Summary text displayed in the summary notification.
*/
groupMessage?: string;
/**
* List of action buttons on the notification.
*/
actionButtons: OSActionButton[];
/**
* **ANDROID** - The Google project number the notification was sent under.
*/
fromProjectNumber?: string;
/**
* **ANDROID** - If a background image was set this object will be available.
*/
backgroundImageLayout?: OSBackgroundImageLayout;
priority?: number;
/**
* List of action buttons on the notification.
*/
rawPayload: string;
}
/**
* List of action buttons on the notification.
*/
export interface OSActionButton {
/**
* Id assigned to the button.
*/
id: string;
/**
* Text show on the button to the user.
*/
text: string;
/**
* **ANDROID** - Icon shown on the button.
*/
icon: string;
}
/**
* **ANDROID** - If a background image was set, this object will be available.
*/
export interface OSBackgroundImageLayout {
/**
* Image URL or name used as the background image.
*/
image: string;
/**
* Text color of the title on the notification. ARGB Format.
*/
titleTextColor: string;
/**
* Text color of the body on the notification. ARGB Format.
*/
bodyTextColor: string;
}
/**
* The information returned from a notification the user received.
*/
export interface OSNotificationOpenedResult {
action: {
/**
* Was the notification opened normally (`Opened`) or was a button pressed on the notification (`ActionTaken`).
*/
type: OSActionType;
/**
* If `type` == `ActionTaken` then this will contain the id of the button pressed.
*/
actionID?: string;
};
notification: OSNotification;
}
export enum OSActionType {
Opened = 0,
ActionTake = 1
}
/**
* @name OneSignal
* @description
* The OneSignal plugin is an client implementation for using the [OneSignal](https://onesignal.com/) Service.
* OneSignal is a simple implementation for delivering push notifications.
*
* Requires Cordova plugin: `onesignal-cordova-plugin`. For more info, please see the [OneSignal Cordova Docs](https://documentation.onesignal.com/docs/phonegap-sdk-installation).
*
* @usage
* ```typescript
* import { OneSignal } from '@ionic-native/onesignal';
*
* constructor(private oneSignal: OneSignal) { }
*
* ...
*
* this.oneSignal.startInit('b2f7f966-d8cc-11e4-bed1-df8f05be55ba', '703322744261');
*
* this.oneSignal.inFocusDisplaying(this.oneSignal.OSInFocusDisplayOption.InAppAlert);
*
* this.oneSignal.handleNotificationReceived().subscribe(() => {
* // do something when notification is received
* });
*
* this.oneSignal.handleNotificationOpened().subscribe(() => {
* // do something when a notification is opened
* });
*
* this.oneSignal.endInit();
* ```
* @interfaces
* OSNotification
* OSLockScreenVisibility
* OSDisplayType
* OSNotificationPayload
* OSActionButton
* OSBackgroundImageLayout
* OSNotificationOpenedResult
* OSActionType
*/
@Plugin({
pluginName: 'OneSignal',
plugin: 'onesignal-cordova-plugin',
pluginRef: 'plugins.OneSignal',
repo: 'https://github.com/OneSignal/OneSignal-Cordova-SDK',
platforms: ['Android', 'iOS', 'Windows', 'FireOS']
})
@Injectable()
export class OneSignal {
/**
* constants to use in inFocusDisplaying()
*/
OSInFocusDisplayOption = {
None: 0,
InAppAlert : 1,
Notification : 2
};
/**
* Start the initialization process. Once you are done configuring OneSignal, call the `endInit` function.
*
* @param {string} appId Your OneSignal app id
* @param {string} googleProjectNumber **ANDROID** - your Google project number; only required for Android GCM/FCM pushes.
* @returns {any}
*/
@Cordova({ sync: true })
startInit(appId: string, googleProjectNumber?: string): any { return; }
/**
* Callback to run when a notification is received, whether it was displayed or not.
*
* @return {Observable<OneSignalReceivedNotification>}
*/
@Cordova({
observable: true
})
handleNotificationReceived(): Observable<OSNotification> { return; }
/**
* Callback to run when a notification is tapped on from the notification shade (**ANDROID**) or notification
* center (**iOS**), or when closing an Alert notification shown in the app (if InAppAlert is enabled in
* inFocusDisplaying).
*
* @return {Observable<OneSignalOpenedNotification>}
*/
@Cordova({
observable: true
})
handleNotificationOpened(): Observable<OSNotificationOpenedResult> { return; }
/**
* **iOS** - Settings for iOS apps
*
* @param settings
* kOSSettingsKeyAutoPrompt: boolean = true
* Auto prompt user for notification permissions.
*
* kOSSettingsKeyInAppLaunchURL: boolean = false
* Launch notifications with a launch URL as an in app webview.
* @returns {any}
*/
@Cordova({ sync: true })
iOSSettings(settings: {
kOSSettingsKeyAutoPrompt: boolean;
kOSSettingsKeyInAppLaunchURL: boolean;
}): any { return; }
/**
* Must be called after `startInit` to complete initialization of OneSignal.
*
* @returns {any}
*/
@Cordova({ sync: true })
endInit(): any { return; }
/**
* Retrieve a list of tags that have been set on the user from the OneSignal server.
*
* @returns {Promise<any>} Returns a Promise that resolves when tags are recieved.
*/
@Cordova()
getTags(): Promise<any> { return; }
/**
* Lets you retrieve the OneSignal user id and device token.
* Your handler is called after the device is successfully registered with OneSignal.
*
* @returns {Promise<Object>} Returns a Promise that resolves if the device was successfully registered.
*
* userId {string} OneSignal userId is a UUID formatted string. (unique per device per app)
*
* pushToken {string} A push token is a Google/Apple assigned identifier(unique per device per app).
*/
@Cordova()
getIds(): Promise<{userId: string; pushToken: string}> { return; }
/**
* Tag a user based on an app event of your choosing so later you can create segments on [onesignal.com](https://onesignal.com/) to target these users.
* Recommend using sendTags over sendTag if you need to set more than one tag on a user at a time.
*
* @param {string} Key of your choosing to create or update.
* @param {string} Value to set on the key. NOTE: Passing in a blank String deletes the key, you can also call deleteTag.
*/
@Cordova({ sync: true })
sendTag(key: string, value: string): void { }
/**
* Tag a user based on an app event of your choosing so later you can create segments on [onesignal.com](https://onesignal.com/) to target these users.
* Recommend using sendTags over sendTag if you need to set more than one tag on a user at a time.
*
* @param {string} Pass a json object with key/value pairs like: {key: "value", key2: "value2"}
*/
@Cordova({ sync: true })
sendTags(json: any): void { }
/**
* Deletes a tag that was previously set on a user with `sendTag` or `sendTags`. Use `deleteTags` if you need to delete more than one.
*
* @param {string} Key to remove.
*/
@Cordova({ sync: true })
deleteTag(key: string): void { }
/**
* Deletes tags that were previously set on a user with `sendTag` or `sendTags`.
*
* @param {Array<string>} Keys to remove.
*/
@Cordova({ sync: true })
deleteTags(keys: string[]): void { }
/**
* Call this when you would like to prompt an iOS user to accept push notifications with the default system prompt.
* Only works if you set `kOSSettingsAutoPrompt` to `false` in `iOSSettings`
*/
@Cordova({ sync: true })
registerForPushNotifications(): void { }
/**
* Warning:
* Only applies to Android and Amazon. You can call this from your UI from a button press for example to give your user's options for your notifications.
*
* By default OneSignal always vibrates the device when a notification is displayed unless the device is in a total silent mode.
* Passing false means that the device will only vibrate lightly when the device is in it's vibrate only mode.
*
* @param {boolean} false to disable vibrate, true to re-enable it.
*/
@Cordova({ sync: true })
enableVibrate(enable: boolean): void { }
/**
* Warning:
* Only applies to Android and Amazon. You can call this from your UI from a button press for example to give your user's options for your notifications.
*
* By default OneSignal plays the system's default notification sound when the device's notification system volume is turned on.
* Passing false means that the device will only vibrate unless the device is set to a total silent mode.
*
* @param {boolean} false to disable sound, true to re-enable it.
*/
@Cordova({ sync: true })
enableSound(enable: boolean): void { }
/**
*
* Setting to control how OneSignal notifications will be shown when one is received while your app is in focus. By default this is set to inAppAlert, which can be helpful during development.
*
* @param {DisplayType} displayOption
* @returns {any}
*/
@Cordova({ sync: true })
inFocusDisplaying(displayOption: OSDisplayType): any { return; }
/**
* You can call this method with false to opt users out of receiving all notifications through OneSignal.
* You can pass true later to opt users back into notifications.
*
* @param {boolean} enable
*/
@Cordova({ sync: true })
setSubscription(enable: boolean): void { }
/**
*
* @param {notificationObj} Parameters see POST [documentation](https://documentation.onesignal.com/v2.0/docs/notifications-create-notification)
* @returns {Promise<any>} Returns a Promise that resolves if the notification was send successfully.
*/
@Cordova()
postNotification(notificationObj: OSNotification): Promise<any> { return; }
/**
* Prompts the user for location permission to allow geotagging based on the "Location radius" filter on the OneSignal dashboard.
*/
@Cordova({ sync: true })
promptLocation(): void { }
/**
*
* @param email {string}
*/
@Cordova({ sync: true })
syncHashedEmail(email: string): void { }
/**
* Enable logging to help debug if you run into an issue setting up OneSignal.
* The logging levels are as follows: 0 = None, 1= Fatal, 2 = Errors, 3 = Warnings, 4 = Info, 5 = Debug, 6 = Verbose
* The higher the value the more information is shown.
*
* @param {loglevel} contains two properties: logLevel (for console logging) and visualLevel (for dialog messages)
*/
@Cordova({ sync: true })
setLogLevel(logLevel: {
logLevel: number,
visualLevel: number
}): void { }
}
src/@ionic-native/plugins/paypal/index.ts
+477
View File
@@ -0,0 +1,477 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name PayPal
* @description
* PayPal plugin for Cordova/Ionic Applications
*
* @usage
* ```
* import { PayPal, PayPalPayment, PayPalConfiguration } from '@ionic-native/pay-pal';
*
* constructor(private payPal: PayPal) { }
*
* ...
*
*
* this.payPal.init({
* PayPalEnvironmentProduction: "YOUR_PRODUCTION_CLIENT_ID",
* PayPalEnvironmentSandbox: "YOUR_SANDBOX_CLIENT_ID"
* }).then(() => {
* // Environments: PayPalEnvironmentNoNetwork, PayPalEnvironmentSandbox, PayPalEnvironmentProduction
* this.payPal.prepareToRender('PayPalEnvironmentSandbox', new PayPalConfiguration({
* // Only needed if you get an "Internal Service Error" after PayPal login!
* //payPalShippingAddressOption: 2 // PayPalShippingAddressOptionPayPal
* })).then(() => {
* let payment = new PayPalPayment('3.33', 'USD', 'Description', 'sale');
* this.payPal.renderSinglePaymentUI(payment).then(() => {
* // Successfully paid
*
* // Example sandbox response
* //
* // {
* // "client": {
* // "environment": "sandbox",
* // "product_name": "PayPal iOS SDK",
* // "paypal_sdk_version": "2.16.0",
* // "platform": "iOS"
* // },
* // "response_type": "payment",
* // "response": {
* // "id": "PAY-1AB23456CD789012EF34GHIJ",
* // "state": "approved",
* // "create_time": "2016-10-03T13:33:33Z",
* // "intent": "sale"
* // }
* // }
* }, () => {
* // Error or render dialog closed without being successful
* });
* }, () => {
* // Error in configuration
* });
* }, () => {
* // Error in initialization, maybe PayPal isn't supported or something else
* });
* ```
* @interfaces
* PayPalEnvironment
* PayPalConfigurationOptions
* @classes
* PayPalPayment
* PayPalItem
* PayPalPaymentDetails
* PayPalShippingAddress
*/
@Plugin({
pluginName: 'PayPal',
plugin: 'com.paypal.cordova.mobilesdk',
pluginRef: 'PayPalMobile',
repo: 'https://github.com/paypal/PayPal-Cordova-Plugin'
})
@Injectable()
export class PayPal {
/**
* Retrieve the version of the PayPal iOS SDK library. Useful when contacting support.
* @returns {Promise<string>}
*/
@Cordova()
version(): Promise<string> {return; }
/**
* You must preconnect to PayPal to prepare the device for processing payments.
* This improves the user experience, by making the presentation of the
* UI faster. The preconnect is valid for a limited time, so
* the recommended time to preconnect is on page load.
*
* @param {PayPalEnvironment} clientIdsForEnvironments: set of client ids for environments
* @returns {Promise<any>}
*/
@Cordova()
init(clientIdsForEnvironments: PayPalEnvironment): Promise<any> {return; }
/**
* You must preconnect to PayPal to prepare the device for processing payments.
* This improves the user experience, by making the presentation of the UI faster.
* The preconnect is valid for a limited time, so the recommended time to preconnect is on page load.
*
* @param {String} environment: available options are "PayPalEnvironmentNoNetwork", "PayPalEnvironmentProduction" and "PayPalEnvironmentSandbox"
* @param {PayPalConfiguration} configuration: PayPalConfiguration object, for Future Payments merchantName, merchantPrivacyPolicyURL and merchantUserAgreementURL must be set be set
* @returns {Promise<any>}
*/
@Cordova()
prepareToRender(environment: string, configuration: PayPalConfiguration): Promise<any> {return; }
/**
* Start PayPal UI to collect payment from the user.
* See https://developer.paypal.com/webapps/developer/docs/integration/mobile/ios-integration-guide/
* for more documentation of the params.
*
* @param {PayPalPayment} payment PayPalPayment object
* @returns {Promise<any>}
*/
@Cordova()
renderSinglePaymentUI(payment: PayPalPayment): Promise<any> {return; }
/**
* Once a user has consented to future payments, when the user subsequently initiates a PayPal payment
* from their device to be completed by your server, PayPal uses a Correlation ID to verify that the
* payment is originating from a valid, user-consented device+application.
* This helps reduce fraud and decrease declines.
* This method MUST be called prior to initiating a pre-consented payment (a "future payment") from a mobile device.
* Pass the result to your server, to include in the payment request sent to PayPal.
* Do not otherwise cache or store this value.
* @returns {Promise<any>}
*/
@Cordova()
clientMetadataID(): Promise<any> {return; }
/**
* Please Read Docs on Future Payments at https://github.com/paypal/PayPal-iOS-SDK#future-payments
* @returns {Promise<any>}
*/
@Cordova()
renderFuturePaymentUI(): Promise<any> {return; }
/**
* Please Read Docs on Profile Sharing at https://github.com/paypal/PayPal-iOS-SDK#profile-sharing
*
* @param {Array<string>} scopes scopes Set of requested scope-values. Accepted scopes are: openid, profile, address, email, phone, futurepayments and paypalattributes
* See https://developer.paypal.com/docs/integration/direct/identity/attributes/ for more details
* @returns {Promise<any>}
*/
@Cordova()
renderProfileSharingUI(scopes: string[]): Promise<any> {return; }
}
export interface PayPalEnvironment {
PayPalEnvironmentProduction: string;
PayPalEnvironmentSandbox: string;
}
/**
* @hidden
*/
export class PayPalPayment {
constructor(amount: string, currency: string, shortDescription: string, intent: string, details?: PayPalPaymentDetails) {
this.amount = amount;
this.currency = currency;
this.shortDescription = shortDescription;
this.intent = intent;
this.details = details;
}
/**
* The amount of the payment.
*/
amount: string;
/**
* The ISO 4217 currency for the payment.
*/
currency: string;
/**
* A short description of the payment.
*/
shortDescription: string;
/**
* "Sale" for an immediate payment.
*/
intent: string;
/**
* Optional Build Notation code ("BN code"), obtained from partnerprogram@paypal.com,
* for your tracking purposes.
*/
bnCode: string = 'PhoneGap_SP';
/**
* Optional invoice number, for your tracking purposes. (up to 256 characters)
*/
invoiceNumber: string;
/**
* Optional text, for your tracking purposes. (up to 256 characters)
*/
custom: string;
/**
* Optional text which will appear on the customer's credit card statement. (up to 22 characters)
*/
softDescriptor: string;
/**
* Optional array of PayPalItem objects.
*/
items: Array<PayPalItem>;
/**
* Optional customer shipping address, if your app wishes to provide this to the SDK.
*/
shippingAddress: string;
/**
* Optional PayPalPaymentDetails object
*/
details: PayPalPaymentDetails;
}
/**
* @hidden
*/
export class PayPalItem {
/**
* The PayPalItem class defines an optional itemization for a payment.
* @see https://developer.paypal.com/docs/api/#item-object for more details.
* @param {String} name: Name of the item. 127 characters max
* @param {Number} quantity: Number of units. 10 characters max.
* @param {String} price: Unit price for this item 10 characters max.
* May be negative for "coupon" etc
* @param {String} currency: ISO standard currency code.
* @param {String} sku: The stock keeping unit for this item. 50 characters max (optional)
*/
constructor(name: string, quantity: number, price: string, currency: string, sku?: string) {
this.name = name;
this.quantity = quantity;
this.price = price;
this.currency = currency;
this.sku = sku;
}
/**
* Name of the item. 127 characters max
*/
name: string;
/**
* Number of units. 10 characters max.
*/
quantity: number;
/**
* Unit price for this item 10 characters max.
*/
price: string;
/**
* ISO standard currency code.
*/
currency: string;
/**
* The stock keeping unit for this item. 50 characters max (optional)
*/
sku?: string;
}
/**
* @hidden
*/
export class PayPalPaymentDetails {
/**
* The PayPalPaymentDetails class defines optional amount details.
* @param {String} subtotal: Sub-total (amount) of items being paid for. 10 characters max with support for 2 decimal places.
* @param {String} shipping: Amount charged for shipping. 10 characters max with support for 2 decimal places.
* @param {String} tax: Amount charged for tax. 10 characters max with support for 2 decimal places.
*/
constructor(subtotal: string, shipping: string, tax: string) {
this.subtotal = subtotal;
this.shipping = shipping;
this.tax = tax;
}
/**
* Sub-total (amount) of items being paid for. 10 characters max with support for 2 decimal places.
*/
subtotal: string;
/**
* Amount charged for shipping. 10 characters max with support for 2 decimal places.
*/
shipping: string;
/**
* Amount charged for tax. 10 characters max with support for 2 decimal places.
*/
tax: string;
}
/**
* @hidden
*/
export interface PayPalConfigurationOptions {
/**
* Will be overridden by email used in most recent PayPal login.
*/
defaultUserEmail?: string;
/**
* Will be overridden by phone country code used in most recent PayPal login
*/
defaultUserPhoneCountryCode?: string;
/**
* Will be overridden by phone number used in most recent PayPal login.
*/
defaultUserPhoneNumber?: string;
/**
* Your company name, as it should be displayed to the user when requesting consent via a PayPalFuturePaymentViewController.
*/
merchantName?: string;
/**
* URL of your company's privacy policy, which will be offered to the user when requesting consent via a PayPalFuturePaymentViewController.
*/
merchantPrivacyPolicyURL?: string;
/**
* URL of your company's user agreement, which will be offered to the user when requesting consent via a PayPalFuturePaymentViewController.
*/
merchantUserAgreementURL?: string;
/**
* If set to NO, the SDK will only support paying with PayPal, not with credit cards.
* This applies only to single payments (via PayPalPaymentViewController).
* Future payments (via PayPalFuturePaymentViewController) always use PayPal.
* Defaults to true
*/
acceptCreditCards?: boolean;
/**
* For single payments, options for the shipping address.
* - 0 - PayPalShippingAddressOptionNone: no shipping address applies.
* - 1 - PayPalShippingAddressOptionProvided: shipping address will be provided by your app,
* in the shippingAddress property of PayPalPayment.
* - 2 - PayPalShippingAddressOptionPayPal: user will choose from shipping addresses on file
* for their PayPal account.
* - 3 - PayPalShippingAddressOptionBoth: user will choose from the shipping address provided by your app,
* in the shippingAddress property of PayPalPayment, plus the shipping addresses on file for the user's PayPal account.
* Defaults to 0 (PayPalShippingAddressOptionNone).
*/
payPalShippingAddressOption?: number;
/**
* If set to YES, then if the user pays via their PayPal account,
* the SDK will remember the user's PayPal username or phone number;
* if the user pays via their credit card, then the SDK will remember
* the PayPal Vault token representing the user's credit card.
*
* If set to NO, then any previously-remembered username, phone number, or
* credit card token will be erased, and subsequent payment information will
* not be remembered.
*
* Defaults to YES.
*/
rememberUser?: boolean;
/**
* If not set, or if set to nil, defaults to the device's current language setting.
*
* Can be specified as a language code ("en", "fr", "zh-Hans", etc.) or as a locale ("en_AU", "fr_FR", "zh-Hant_HK", etc.).
* If the library does not contain localized strings for a specified locale, then will fall back to the language. E.g., "es_CO" -> "es".
* If the library does not contain localized strings for a specified language, then will fall back to American English.
*
* If you specify only a language code, and that code matches the device's currently preferred language,
* then the library will attempt to use the device's current region as well.
* E.g., specifying "en" on a device set to "English" and "United Kingdom" will result in "en_GB".
*/
languageOrLocale?: string;
/**
* Normally, the SDK blurs the screen when the app is backgrounded,
* to obscure credit card or PayPal account details in the iOS-saved screenshot.
* If your app already does its own blurring upon backgrounding, you might choose to disable this.
* Defaults to NO.
*/
disableBlurWhenBackgrounding?: boolean;
/**
* If you will present the SDK's view controller within a popover, then set this property to YES.
* Defaults to NO. (iOS only)
*/
presentingInPopover?: boolean;
/**
* Sandbox credentials can be difficult to type on a mobile device. Setting this flag to YES will
* cause the sandboxUserPassword and sandboxUserPin to always be pre-populated into login fields.
*/
forceDefaultsInSandbox?: boolean;
/**
* Password to use for sandbox if 'forceDefaultsInSandbox' is set.
*/
sandboxUserPassword?: string;
/**
* PIN to use for sandbox if 'forceDefaultsInSandbox' is set.
*/
sandboxUserPin?: string;
}
/**
* @hidden
*/
export class PayPalConfiguration implements PayPalConfigurationOptions {
/**
* You use a PayPalConfiguration object to configure many aspects of how the SDK behaves.
* see defaults for options available
*/
constructor(options?: PayPalConfigurationOptions) {
let defaults: PayPalConfigurationOptions = {
defaultUserEmail: null,
defaultUserPhoneCountryCode: null,
defaultUserPhoneNumber: null,
merchantName: null,
merchantPrivacyPolicyURL: null,
merchantUserAgreementURL: null,
acceptCreditCards: true,
payPalShippingAddressOption: 0,
rememberUser: true,
languageOrLocale: null,
disableBlurWhenBackgrounding: false,
presentingInPopover: false,
forceDefaultsInSandbox: false,
sandboxUserPassword: null,
sandboxUserPin: null
};
if (options && typeof options === 'object') {
for (var i in options) {
if (defaults.hasOwnProperty(i)) {
defaults[i] = options[i];
}
}
}
return defaults;
}
}
/**
* @hidden
*/
export class PayPalShippingAddress {
/**
* See the documentation of the individual properties for more detail.
* @param {String} recipientName: Name of the recipient at this address. 50 characters max.
* @param {String} line1: Line 1 of the address (e.g., Number, street, etc). 100 characters max.
* @param {String} line2: Line 2 of the address (e.g., Suite, apt #, etc). 100 characters max. Optional.
* @param {String} city: City name. 50 characters max.
* @param {String} state: 2-letter code for US states, and the equivalent for other countries. 100 characters max. Required in certain countries.
* @param {String} postalCode: ZIP code or equivalent is usually required for countries that have them. 20 characters max. Required in certain countries.
* @param {String} countryCode: 2-letter country code. 2 characters max.
*/
constructor(recipientName: string, line1: string, line2: string, city: string, state: string, postalCode: string, countryCode: string) {
this.recipientName = recipientName;
this.line1 = line1;
this.line2 = line2;
this.city = city;
this.state = state;
this.postalCode = postalCode;
this.countryCode = countryCode;
}
/**
* Name of the recipient at this address. 50 characters max.
*/
recipientName: string;
/**
* Line 1 of the address (e.g., Number, street, etc). 100 characters max.
*/
line1: string;
/**
* Line 2 of the address (e.g., Suite, apt #, etc). 100 characters max. Optional.
*/
line2: string;
/**
* City name. 50 characters max.
*/
city: string;
/**
* 2-letter code for US states, and the equivalent for other countries. 100 characters max. Required in certain countries.
*/
state: string;
/**
* ZIP code or equivalent is usually required for countries that have them. 20 characters max. Required in certain countries.
*/
postalCode: string;
/**
* 2-letter country code. 2 characters max.
*/
countryCode: string;
}
src/@ionic-native/plugins/pedometer/index.ts
+105
View File
@@ -0,0 +1,105 @@
import { Plugin, Cordova } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
import { Injectable } from '@angular/core';
/**
* Interface of a pedometer data object which is returned by watching for new data or by recieving historical data
*/
export interface IPedometerData {
startDate?: number;
endDate?: number;
numberOfSteps: number;
distance: number;
floorsAscended: number;
floorsDescended: number;
}
/**
* @name Pedometer
* @description
* Fetch pedestrian-related pedometer data,
* such as step counts and other information about the distance travelled.
*
* @usage
* ```
* import { Pedometer } from 'ionic-native';
*
* Pedometer.isDistanceAvailable()
* .then((available: boolean) => console.log(available))
* .catch((error: any) => console.log(error));
*
* Pedometer.startPedometerUpdates()
* .subscribe((data: IPedometerData) => {
* console.log(data);
* });
* ```
*/
@Plugin({
pluginName: 'Pedometer',
plugin: 'cordova-plugin-pedometer',
pluginRef: 'pedometer',
repo: 'https://github.com/leecrossley/cordova-plugin-pedometer',
platforms: ['Android', 'iOS']
})
@Injectable()
export class Pedometer {
/**
* Checks if step counting is available. Only works on iOS.
* @return {Promise<boolean>} Returns a promise that resolves when feature is supported (true) or not supported (false)
*/
@Cordova()
isStepCountingAvailable(): Promise<boolean> { return; }
/**
* Distance estimation indicates the ability to use step information to supply the approximate distance travelled by the user.
* This capability is not supported on all devices, even with iOS 8.
* Only works on iOS.
* @return {Promise<boolean>} Returns a promise that resolves when feature is supported (true) or not supported (false)
*/
@Cordova()
isDistanceAvailable(): Promise<boolean> { return; }
/**
* Floor counting indicates the ability to count the number of floors the user walks up or down using stairs.
* This capability is not supported on all devices, even with iOS 8.
* Only works on iOS.
* @return {Promise<boolean>} Returns a promise that resolves when feature is supported (true) or not supported (false)
*/
@Cordova()
isFloorCountingAvailable(): Promise<boolean> { return; }
/**
* Starts the delivery of recent pedestrian-related data to your Cordova app.
*
* When the app is suspended, the delivery of updates stops temporarily.
* Upon returning to foreground or background execution, the pedometer object begins updates again.
* @return {Observable<IPedometerData>} Returns a Observable that recieves repeatly data from pedometer in background.
*/
@Cordova({
observable: true,
clearFunction: 'stopPedometerUpdates'
})
startPedometerUpdates(): Observable<IPedometerData> { return; }
/**
* Stops the delivery of recent pedestrian data updates to your Cordova app.
* @return {Promise<boolean>} Returns a promise that resolves when pedometer watching was stopped
*/
@Cordova()
stopPedometerUpdates(): Promise<any> { return; }
/**
* Retrieves the data between the specified start and end dates.
* The startDate and endDate options are required and can be constructed in any valid JavaScript way
* (e.g. new Date(2015, 4, 1, 15, 20, 00) is also valid, as is milliseconds).
* Only works on iOS.
* @param {any} options start date and en date where you want to get pedometer data
* @return {Promise<IPedometerData>} Returns a promise that resolves when pedometer data found
*/
@Cordova({
callbackOrder: 'reverse'
})
queryData(options: { startDate: Date, endDate: Date }): Promise<IPedometerData> { return; }
}
src/@ionic-native/plugins/photo-library/index.ts
+223
View File
@@ -0,0 +1,223 @@
import { Plugin, Cordova, CordovaFiniteObservable } from '@ionic-native/core';
import { Observable } from 'rxjs/Observable';
import { Injectable } from '@angular/core';
/**
* @name Photo Library
* @description
* The PhotoLibrary plugin allows access to photos from device by url. So you can use plain img tag to display photos and their thumbnails, and different 3rd party libraries as well.
* Saving photos and videos to the library is also supported.
* cdvphotolibrary urls should be trusted by Angular. See plugin homepage to learn how.
*
* @usage
* ```
* import { PhotoLibrary } from '@ionic-native/photo-library';
*
* constructor(private photoLibrary: PhotoLibrary) { }
*
* this.photoLibrary.requestAuthorization().then(() => {
* this.photoLibrary.getLibrary().subscribe({
* next: library => {
* library.forEach(function(libraryItem) {
* console.log(libraryItem.id); // ID of the photo
* console.log(libraryItem.photoURL); // Cross-platform access to photo
* console.log(libraryItem.thumbnailURL);// Cross-platform access to thumbnail
* console.log(libraryItem.fileName);
* console.log(libraryItem.width);
* console.log(libraryItem.height);
* console.log(libraryItem.creationDate);
* console.log(libraryItem.latitude);
* console.log(libraryItem.longitude);
* console.log(libraryItem.albumIds); // array of ids of appropriate AlbumItem, only of includeAlbumsData was used
* });
* },
* error: err => {},
* complete: () => { console.log("could not get photos"); }
* });
* })
* .catch(err => console.log("permissions weren't granted"));
*
* ```
*/
@Plugin({
pluginName: 'PhotoLibrary',
plugin: 'cordova-plugin-photo-library',
pluginRef: 'cordova.plugins.photoLibrary',
repo: 'https://github.com/terikon/cordova-plugin-photo-library',
install: 'ionic plugin add cordova-plugin-photo-library --variable PHOTO_LIBRARY_USAGE_DESCRIPTION="To choose photos"'
})
@Injectable()
export class PhotoLibrary {
/**
* Retrieves library items. Library item contains photo metadata like width and height, as well as photoURL and thumbnailURL.
* @param options {GetLibraryOptions} Optional, like thumbnail size and chunks settings.
* @return {Observable<LibraryItem[]>} Returns library items. If appropriate option was set, will be returned by chunks.
*/
@CordovaFiniteObservable({
callbackOrder: 'reverse',
resultFinalPredicate: (result: {isLastChunk: boolean}) => { return result.isLastChunk; },
resultTransform: (result: {library: LibraryItem[]}) => { return result.library; },
})
getLibrary(options?: GetLibraryOptions): Observable<LibraryItem[]> { return; }
/**
* Asks user permission to access photo library.
* @param options {RequestAuthorizationOptions} Optional, like whether only read access needed or read/write.
* @return { Promise<void>} Returns a promise that resolves when permissions are granted, and fails when not.
*/
@Cordova({
callbackOrder: 'reverse',
})
requestAuthorization(options?: RequestAuthorizationOptions): Promise<void> { return; }
/**
* Returns list of photo albums on device.
* @return {Promise<AlbumItem[]>} Resolves to list of albums.
*/
@Cordova({
callbackOrder: 'reverse',
})
getAlbums(): Promise<AlbumItem[]> { return; }
/**
* Provides means to request URL of thumbnail, with specified size or quality.
* @param photo {string | LibraryItem} Id of photo, or LibraryItem.
* @param options {GetThumbnailOptions} Options, like thumbnail size or quality.
* @return {Promise<string>} Resolves to URL of cdvphotolibrary schema.
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
getThumbnailURL(photo: string | LibraryItem, options?: GetThumbnailOptions): Promise<string> { return; }
/**
* Provides means to request photo URL by id.
* @param photo {string | LibraryItem} Id or LibraryItem.
* @param options {GetPhotoOptions} Optional options.
* @return {Promise<string>} Resolves to URL of cdvphotolibrary schema.
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
getPhotoURL(photo: string | LibraryItem, options?: any): Promise<string> { return; }
/**
* Returns thumbnail as Blob.
* @param photo {string | LibraryItem} Id or LibraryItem.
* @param options {GetThumbnailOptions} Options, like thumbnail size or quality.
* @return {Promise<Blob>} Resolves requested thumbnail as blob.
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
getThumbnail(photo: string | LibraryItem, options?: GetThumbnailOptions): Promise<Blob> { return; }
/**
* Returns photo as Blob.
* @param photo {string | LibraryItem} Id or LibraryItem.
* @param options {GetPhotoOptions} Optional options.
* @return {Promise<Blob>} Resolves requested photo as blob.
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
getPhoto(photo: string | LibraryItem, options?: any): Promise<Blob> { return; }
/**
* Saves image to specified album. Album will be created if not exists.
* LibraryItem that represents saved image is returned.
* @param url {string} URL of a file, or DataURL.
* @param album {AlbumItem | string} Name of an album or AlbumItem object.
* @param options {GetThumbnailOptions} Options, like thumbnail size for resulting LibraryItem.
* @return {Promise<LibraryItem>} Resolves to LibraryItem that represents saved image.
*/
@Cordova({
successIndex: 2,
errorIndex: 3
})
saveImage(url: string, album: AlbumItem | string, options?: GetThumbnailOptions): Promise<LibraryItem> { return; }
/**
* Saves video to specified album. Album will be created if not exists.
* @param url {string} URL of a file, or DataURL.
* @param album {AlbumItem | string} Name of an album or AlbumItem object.
* @return {Promise<void>} Resolves when save operation completes.
*/
@Cordova({
successIndex: 2,
errorIndex: 3
})
saveVideo(url: string, album: AlbumItem | string): Promise<void> { return; }
}
/**
* @hidden
*/
export interface LibraryItem {
/**
* Local id of the photo
*/
id: string;
/**
* URL of cdvphotolibrary schema.
*/
photoURL: string;
/**
* URL of cdvphotolibrary schema.
*/
thumbnailURL: string;
fileName: string;
width: number;
height: number;
creationDate: Date;
latitude?: number;
longitude?: number;
albumIds?: string[];
}
/**
* @hidden
*/
export interface AlbumItem {
/**
* Local id of the album
*/
id: string;
title: string;
}
/**
* @hidden
*/
export interface GetLibraryOptions {
thumbnailWidth?: number;
thumbnailHeight?: number;
quality?: number;
itemsInChunk?: number;
chunkTimeSec?: number;
useOriginalFileNames?: boolean;
includeAlbumData?: boolean;
}
/**
* @hidden
*/
export interface RequestAuthorizationOptions {
read?: boolean;
write?: boolean;
}
/**
* @hidden
*/
export interface GetThumbnailOptions {
thumbnailWidth?: number;
thumbnailHeight?: number;
quality?: number;
}
src/@ionic-native/plugins/photo-viewer/index.ts
+35
View File
@@ -0,0 +1,35 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Photo Viewer
* @description This plugin can display your image in full screen with the ability to pan, zoom, and share the image.
* @usage
* ```typescript
* import { PhotoViewer } from '@ionic-native/photo-viewer';
*
* constructor(private photoViewer: PhotoViewer) { }
*
* ...
*
* this.photoViewer.show('https://mysite.com/path/to/image.jpg');
*
* this.photoViewer.show('https://mysite.com/path/to/image.jpg', 'My image title', {share: false});
* ```
*/
@Plugin({
pluginName: 'PhotoViewer',
plugin: 'com-sarriaroman-photoviewer',
pluginRef: 'PhotoViewer',
repo: 'https://github.com/sarriaroman/photoviewer'
})
@Injectable()
export class PhotoViewer {
/**
* Shows an image in full screen
* @param url {string} URL or path to image
* @param title {string}
* @param options {any}
*/
@Cordova({sync: true})
show(url: string, title?: string, options?: {share?: boolean}): void { }
}
src/@ionic-native/plugins/pin-dialog/index.ts
+48
View File
@@ -0,0 +1,48 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
/**
* @name Pin Dialog
* @description
*
* @usage
* ```typescript
* import { PinDialog } from '@ionic-native/pin-dialog';
*
*
* constructor(private pinDialog: PinDialog) { }
*
* ...
*
* this.pinDialog.prompt('Enter your PIN', 'Verify PIN', ['OK', 'Cancel'])
* .then(
* (result: any) => {
* if (result.buttonIndex == 1) console.log('User clicked OK, value is: ', result.input1);
* else if(result.buttonIndex == 2) console.log('User cancelled');
* }
* );
* ```
*/
@Plugin({
pluginName: 'PinDialog',
plugin: 'cordova-plugin-pin-dialog',
pluginRef: 'plugins.pinDialog',
repo: 'https://github.com/Paldom/PinDialog'
})
@Injectable()
export class PinDialog {
/**
* Show pin dialog
* @param {string} message Message to show the user
* @param {string} title Title of the dialog
* @param {string[]} buttons Buttons to show
* @returns {Promise<{ buttonIndex: number, input1: string }>}
*/
@Cordova({
successIndex: 1,
errorIndex: 4 // no error callback
})
prompt(message: string, title: string, buttons: string[]): Promise<{ buttonIndex: number, input1: string }> { return; }
}
src/@ionic-native/plugins/pinterest/index.ts
+368
View File
@@ -0,0 +1,368 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova, CordovaProperty } from '@ionic-native/core';
export interface PinterestUser {
/**
* The unique string of numbers and letters that identifies the user on Pinterest.
*/
id?: string;
/**
* The user’s Pinterest username.
*/
username?: string;
/**
* The user’s first name.
*/
first_name?: string;
/**
* The user’s last name.
*/
last_name?: string;
/**
* The text in the user’s “About you” section in their profile.
*/
bio?: string;
/**
* The date the user created their account in ISO 8601 format
*/
created_at?: string;
/**
* The user’s stats, including how many Pins, follows, boards and likes they have.
*/
counts?: any;
/**
* The user’s profile image. The response returns the image’s URL, width and height.
*/
image?: any;
}
export interface PinterestBoard {
/**
* The unique string of numbers and letters that identifies the board on Pinterest.
*/
id?: string;
/**
* The name of the board.
*/
name?: string;
/**
* The link to the board.
*/
url?: string;
/**
* The user-entered description of the board.
*/
description?: string;
/**
* The first and last name, ID and profile URL of the user who created the board.
*/
creator?: PinterestUser;
/**
* The date the user created the board.
*/
created_at?: string;
/**
* The board’s stats, including how many Pins, followers, user's following and collaborators it has.
*/
counts?: any;
/**
* The user’s profile image. The response returns the image’s URL, width and height.
*/
image?: any;
}
export interface PinterestPin {
/**
* The unique string of numbers and letters that identifies the Pin on Pinterest.
*/
id?: string;
/**
* The URL of the webpage where the Pin was created.
*/
link?: string;
/**
* The URL of the Pin on Pinterest.
*/
url?: string;
/**
* The first and last name, ID and profile URL of the user who created the board.
*/
creator?: PinterestUser;
/**
* The board that the Pin is on.
*/
board?: PinterestBoard;
/**
* The date the Pin was created.
*/
created_at?: string;
/**
* The user-entered description of the Pin.
*/
note?: string;
/**
* The dominant color of the Pin’s image in hex code format.
*/
color?: string;
/**
* The Pin’s stats, including the number of repins, comments and likes.
*/
counts?: any;
/**
* The media type of the Pin (image or video).
*/
media?: any;
/**
* The source data for videos, including the title, URL, provider, author name, author URL and provider name.
*/
attribution?: any;
/**
* The Pin’s image. The default response returns the image’s URL, width and height.
*/
image?: any;
/**
* Extra information about the Pin for Rich Pins. Includes the Pin type (e.g., article, recipe) and related information (e.g., ingredients, author).
*/
metadata?: any;
}
/**
* @beta
* @name Pinterest
* @description
* Cordova plugin for Pinterest
*
* @usage
* ```
* import { Pinterest, PinterestUser, PinterestPin, PinterestBoard } from '@ionic-native/pinterest';
*
* constructor(private pinterest: Pinterest) { }
*
* ...
*
* const scopes = [
* this.pinterest.SCOPES.READ_PUBLIC,
* this.pinterest.SCOPES.WRITE_PUBLIC,
* this.pinterest.SCOPES.READ_RELATIONSHIPS,
* this.pinterest.SCOPES.WRITE_RELATIONSHIPS
* ];
*
* this.pinterest.login(scopes)
* .then(res => console.log('Logged in!', res))
* .catch(err => console.error('Error loggin in', err));
*
* this.pinterest.getMyPins()
* .then((pins: Array<PinterestPin>) => console.log(pins))
* .catch(err => console.error(err));
*
* this.pinterest.getMe()
* .then((user: PinterestUser) => console.log(user));
*
* this.pinterest.getMyBoards()
* .then((boards: Array<PinterestBoard>) => console.log(boards));
*
* ```
* @interfaces
* PinterestUser
* PinterestBoard
* PinterestPin
*/
@Plugin({
pluginName: 'Pinterest',
plugin: 'cordova-plugin-pinterest',
pluginRef: 'cordova.plugins.Pinterest',
repo: 'https://github.com/zyramedia/cordova-plugin-pinterest',
install: 'ionic plugin add cordova-plugin-pinterest --variable APP_ID=YOUR_APP_ID',
installVariables: ['APP_ID'],
platforms: ['Android', 'iOS']
})
@Injectable()
export class Pinterest {
/**
* Convenience constant for authentication scopes
*/
@CordovaProperty
SCOPES: {
READ_PUBLIC: string;
WRITE_PUBLIC: string;
READ_RELATIONSHIPS: string;
WRITE_RELATIONSHIPS: string;
};
/**
* Logs the user in using their Pinterest account.
* @param scopes {Array<string>} Array of scopes that you need access to. You can use Pinterest.SCOPES constant for convenience.
* @returns {Promise<any>} The response object will contain the user's profile data, as well as the access token (if you need to use it elsewhere, example: send it to your server and perform actions on behalf of the user).
*/
@Cordova()
login(scopes: string[]): Promise<any> { return; }
/**
* Gets the authenticated user's profile
* @param fields {string} Fields to retrieve, separated by commas. Defaults to all available fields.
* @returns {Promise<PinterestUser>} Returns a promise that resolves with the user's object
*/
@Cordova({
callbackOrder: 'reverse'
})
getMe(fields?: string): Promise<PinterestUser> { return; }
/**
*
* @param fields {string} Optional fields separated by comma
* @param limit {number} Optional limit, defaults to 100, maximum is 100.
* @returns {Promise<Array<PinterestPin>>}
*/
@Cordova({
callbackOrder: 'reverse'
})
getMyPins(fields?: string, limit?: number): Promise<Array<PinterestPin>> { return; }
/**
*
* @param fields {string} Optional fields separated by comma
* @param limit {number} Optional limit, defaults to 100, maximum is 100.
* @returns {Promise<Array<PinterestBoard>>}
*/
@Cordova({
callbackOrder: 'reverse'
})
getMyBoards(fields?: string, limit?: number): Promise<Array<PinterestBoard>> { return; }
/**
* Get the authenticated user's likes.
* @param fields {string} Optional fields separated by comma
* @param limit {number} Optional limit, defaults to 100, maximum is 100.
* @returns {Promise<Array<PinterestPin>>}
*/
@Cordova({
callbackOrder: 'reverse'
})
getMyLikes(fields?: string, limit?: number): Promise<Array<PinterestPin>> { return; }
/**
* Get the authenticated user's followers.
* @param fields {string} Optional fields separated by comma
* @param limit {number} Optional limit, defaults to 100, maximum is 100.
* @returns {Promise<Array<PinterestUser>>}
*/
@Cordova({
callbackOrder: 'reverse'
})
getMyFollowers(fields?: string, limit?: number): Promise<Array<PinterestUser>> { return; }
/**
* Get the authenticated user's followed boards.
* @param fields {string} Optional fields separated by comma
* @param limit {number} Optional limit, defaults to 100, maximum is 100.
* @returns {Promise<Array<PinterestBoard>>}
*/
@Cordova({
callbackOrder: 'reverse'
})
getMyFollowedBoards(fields?: string, limit?: number): Promise<Array<PinterestBoard>> { return; }
/**
* Get the authenticated user's followed interests.
* @param fields {string} Optional fields separated by comma
* @param limit {number} Optional limit, defaults to 100, maximum is 100.
* @returns {Promise<any>}
*/
@Cordova({
callbackOrder: 'reverse'
})
getMyFollowedInterests(fields?: string, limit?: number): Promise<any> { return; }
/**
* Get a user's profile.
* @param username
* @param fields
* @returns {Promise<PinterestUser>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
getUser(username: string, fields?: string): Promise<PinterestUser> { return; }
/**
* Get a board's data.
* @param boardId
* @param fields
* @returns {Promise<PinterestBoard>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
getBoard(boardId: string, fields?: string): Promise<PinterestBoard> { return; }
/**
* Get Pins of a specific board.
* @param boardId {string} The ID of the board
* @param fields {string} Optional fields separated by comma
* @param limit {number} Optional limit, defaults to 100, maximum is 100.
* @returns {Promise<Array<PinterestPin>>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
getBoardPins(boardId: string, fields?: string, limit?: number): Promise<Array<PinterestPin>> { return; }
/**
* Delete a board.
* @param boardId {string} The ID of the board
* @returns {Promise<PinterestUser>}
*/
@Cordova()
deleteBoard(boardId: string): Promise<any> { return; }
/**
* Create a new board for the authenticated user.
* @param name {string} Name of the board
* @param desc {string} Optional description of the board
* @returns {Promise<PinterestBoard>}
*/
@Cordova({
successIndex: 2,
errorIndex: 3
})
createBoard(name: string, desc?: string): Promise<PinterestBoard> { return; }
/**
* Get a Pin by ID.
* @param pinId {string} The ID of the Pin
* @param fields {string} Optional fields separated by comma
* @returns {Promise<PinterestPin>}
*/
@Cordova({
successIndex: 1,
errorIndex: 2
})
getPin(pinId: string, fields?: string): Promise<PinterestPin> { return; }
/**
* Deletes a pin
* @param pinId {string} The ID of the pin
* @returns {Promise<any>}
*/
@Cordova()
deletePin(pinId: string): Promise<any> { return; }
/**
* Creates a Pin
* @param note {string} Note/Description of the pin
* @param boardId {string} Board ID to put the Pin under
* @param imageUrl {string} URL of the image to share
* @param link {string} Optional link to share
* @returns {Promise<PinterestPin>}
*/
@Cordova({
successIndex: 4,
errorIndex: 5
})
createPin(note: string, boardId: string, imageUrl: string, link?: string): Promise<PinterestPin> { return; }
}
src/@ionic-native/plugins/power-management/index.ts
+60
View File
@@ -0,0 +1,60 @@
import { Injectable } from '@angular/core';
import { Plugin, Cordova } from '@ionic-native/core';
/**
* @name Power Management
* @description
* The PowerManagement plugin offers access to the devices power-management functionality.
* It should be used for applications which keep running for a long time without any user interaction.
*
* @usage
* ```
* import { PowerManagement } from '@ionic-native/power-management';
*
* constructor(private powerManagement: PowerManagement) { }
*
* ...
*
* this.powerManagement.acquire()
* .then(onSuccess)
* .catch(onError);
*
* ```
*/
@Plugin({
pluginName: 'PowerManagement',
plugin: 'cordova-plugin-powermanagement-orig',
pluginRef: 'powerManagement',
repo: 'https://github.com/Viras-/cordova-plugin-powermanagement'
})
@Injectable()
export class PowerManagement {
/**
* Acquire a wakelock by calling this.
* @returns {Promise<any>}
*/
@Cordova()
acquire(): Promise<any> {return; }
/**
* This acquires a partial wakelock, allowing the screen to be dimmed.
* @returns {Promise<any>}
*/
@Cordova()
dim(): Promise<any> {return; }
/**
* Release the wakelock. It's important to do this when you're finished with the wakelock, to avoid unnecessary battery drain.
* @returns {Promise<any>}
*/
@Cordova()
release(): Promise<any> {return; }
/**
* By default, the plugin will automatically release a wakelock when your app is paused (e.g. when the screen is turned off, or the user switches to another app).
* It will reacquire the wakelock upon app resume. If you would prefer to disable this behaviour, you can use this function.
* @param set {boolean}
* @returns {Promise<any>}
*/
@Cordova()
setReleaseOnPause(set: boolean): Promise<any> {return; }
}
src/@ionic-native/plugins/printer/index.ts
+96
View File
@@ -0,0 +1,96 @@
import { Injectable } from '@angular/core';
import { Cordova, Plugin } from '@ionic-native/core';
declare var cordova: any;
export interface PrintOptions {
/**
* The name of the print job and the document
*/
name?: string;
/**
* The network URL of the printer.
* Only supported on iOS.
*/
printerId?: string;
/**
* Specifies the duplex mode to use for the print job.
* Either double-sided (duplex:true) or single-sided (duplex:false).
* Double-sided by default.
* Only supported on iOS
*/
duplex?: boolean;
/**
* The orientation of the printed content, portrait or landscape
* Portrait by default.
*/
landscape?: boolean;
/**
* If your application only prints black text, setting this property to true can result in better performance in many cases.
* False by default.
*/
grayscale?: boolean;
/**
* The Size and position of the print view
*/
bounds?: number[] | any;
}
/**
* @name Printer
* @description Prints documents or HTML rendered content
* @usage
* ```typescript
* import { Printer, PrintOptions } from '@ionic-native/printer';
*
* constructor(private printer: Printer) { }
*
* ...
*
* this.printer.isAvailable().then(onSuccess, onError);
*
* let options: PrintOptions = {
* name: 'MyDocument',
* printerId: 'printer007',
* duplex: true,
* landscape: true,
* grayscale: true
* };
*
* this.p.print(content, options).then(onSuccess, onError);
* ```
* @interfaces
* PrintOptions
*/
@Plugin({
pluginName: 'Printer',
plugin: 'de.appplant.cordova.plugin.printer',
pluginRef: 'cordova.plugins.printer',
repo: 'https://github.com/katzer/cordova-plugin-printer.git',
platforms: ['Android', 'iOS']
})
@Injectable()
export class Printer {
/**
* Checks whether to device is capable of printing.
* @returns {Promise<boolean>}
*/
@Cordova()
isAvailable(): Promise<boolean> { return; }
/**
* Sends content to the printer.
* @param content {string | HTMLElement} The content to print. Can be a URL or an HTML string. If a HTML DOM Object is provided, its innerHtml property value will be used.
* @param options {PrintOptions} optional. The options to pass to the printer
* @returns {Promise<any>}
*/
@Cordova()
print(content: string | HTMLElement, options?: PrintOptions): Promise<any> { return; }
}

Some files were not shown because too many files have changed in this diff Show More