constructor(platform: Platform, device: Device, appProvider: CoreAppProvider, fileProvider: CoreFileProvider,
            initDelegate: CoreInitDelegate, langProvider: CoreLangProvider, sitesProvider: CoreSitesProvider,
            localNotificationsProvider: CoreLocalNotificationsProvider, pushNotificationsProvider: AddonPushNotificationsProvider) {

        const currentSite = sitesProvider.getCurrentSite();

        this.appName = appProvider.isDesktop() ? CoreConfigConstants.desktopappname : CoreConfigConstants.appname;
        this.versionName = CoreConfigConstants.versionname;
        this.versionCode = CoreConfigConstants.versioncode;
        this.compilationTime = CoreConfigConstants.compilationtime;
        this.lastCommit = CoreConfigConstants.lastcommit;

        // Calculate the privacy policy to use.
        this.privacyPolicy = (currentSite && (currentSite.getStoredConfig('tool_mobile_apppolicy') ||
                currentSite.getStoredConfig('sitepolicy'))) || CoreConfigConstants.privacypolicy;

        this.navigator = window.navigator;
        if (window.location && window.location.href) {
            const url = window.location.href;
            this.locationHref = url.substr(0, url.indexOf('#'));
        }

        this.appReady = initDelegate.isReady() ? 'core.yes' : 'core.no';
        this.deviceType = platform.is('tablet') ? 'core.tablet' : 'core.phone';

        if (platform.is('android')) {
            this.deviceOs = 'core.android';
        } else if (platform.is('ios')) {
            this.deviceOs = 'core.ios';
        } else if (platform.is('windows')) {
            this.deviceOs = 'core.windowsphone';
        } else {
            const matches = navigator.userAgent.match(/\(([^\)]*)\)/);
            if (matches && matches.length > 1) {
                this.deviceOs = matches[1];
            } else {
                this.deviceOs = 'core.unknown';
            }
        }

        langProvider.getCurrentLanguage().then((lang) => {
            this.currentLanguage = lang;
        });

        this.networkStatus = appProvider.isOnline() ? 'core.online' : 'core.offline';
        this.wifiConnection = appProvider.isWifi() ? 'core.yes' : 'core.no';
        this.deviceWebWorkers = !!window['Worker'] && !!window['URL'] ? 'core.yes' : 'core.no';
        this.device = device;

        if (fileProvider.isAvailable()) {
            fileProvider.getBasePath().then((basepath) => {
                this.fileSystemRoot = basepath;
                this.fsClickable = fileProvider.usesHTMLAPI();
            });
        }

        this.localNotifAvailable = localNotificationsProvider.isAvailable() ? 'core.yes' : 'core.no';
        this.pushId = pushNotificationsProvider.getPushId();
    }

    constructor(appProvider: CoreAppProvider) {
        super();

        this.isDesktop = appProvider.isDesktop();
        if (this.isDesktop) {
            this.clipboard = require('electron').clipboard;
        } else {
            // In browser the text must be selected in order to copy it. Create a hidden textarea to put the text in it.
            this.copyTextarea = document.createElement('textarea');
            this.copyTextarea.className = 'core-browser-copy-area';
            this.copyTextarea.setAttribute('aria-hidden', 'true');
            document.body.appendChild(this.copyTextarea);
        }
    }

        this.initDelegate.ready().then(() => {
            // Check if there was a pending redirect.
            const redirectData = this.appProvider.getRedirect();
            if (redirectData.siteId && redirectData.page) {
                // Unset redirect data.
                this.appProvider.storeRedirect('', '', '');

                // Only accept the redirect if it was stored less than 20 seconds ago.
                if (Date.now() - redirectData.timemodified < 20000) {
                    if (redirectData.siteId != CoreConstants.NO_SITE_ID) {
                        // The redirect is pointing to a site, load it.
                        return this.sitesProvider.loadSite(redirectData.siteId, redirectData.page, redirectData.params)
                                .then((loggedIn) => {

                            if (loggedIn) {
                                return this.loginHelper.goToSiteInitialPage(this.navCtrl, redirectData.page, redirectData.params,
                                        { animate: false });
                            }
                        }).catch(() => {
                            // Site doesn't exist.
                            return this.loadPage();
                        });
                    } else {
                        // No site to load, just open the state.
                        return this.navCtrl.setRoot(redirectData.page, redirectData.params, { animate: false });
                    }
                }
            }

            return this.loadPage();
        }).then(() => {

    /**
     * Tries to authenticate the user.
     *
     * @param {Event} e Event.
     */
    login(e: Event): void {
        e.preventDefault();
        e.stopPropagation();

        this.appProvider.closeKeyboard();

        // Get input data.
        const siteUrl = this.siteUrl,
            username = this.username,
            password = this.credForm.value.password;

        if (!password) {
            this.domUtils.showErrorModal('core.login.passwordrequired', true);

            return;
        }

        if (!this.appProvider.isOnline()) {
            this.domUtils.showErrorModal('core.networkerrormsg', true);

            return;
        }

        const modal = this.domUtils.showModalLoading();

        // Start the authentication process.
        this.sitesProvider.getUserToken(siteUrl, username, password).then((data) => {
            return this.sitesProvider.updateSiteToken(this.infoSiteUrl, username, data.token, data.privateToken).then(() => {
                // Update site info too because functions might have changed (e.g. unisntall local_mobile).
                return this.sitesProvider.updateSiteInfoByUrl(this.infoSiteUrl, username).then(() => {
                    // Reset fields so the data is not in the view anymore.
                    this.credForm.controls['password'].reset();

                    if (this.pageName) {
                        // Page defined, go to that page instead of site initial page.
                        return this.navCtrl.setRoot(this.pageName, this.pageParams);
                    } else {
                        return this.loginHelper.goToSiteInitialPage();
                    }
                }).catch((error) => {
                    // Error, go back to login page.
                    this.domUtils.showErrorModalDefault(error, 'core.login.errorupdatesite', true);
                    this.cancel();
                });
            });
        }).catch((error) => {
            this.loginHelper.treatUserTokenError(siteUrl, error, username, password);
        }).finally(() => {
            modal.dismiss();
        });
    }

    /**
     * Loads the component contents and shows the corresponding error.
     *
     * @param {boolean}       [refresh=false] Whether we're refreshing data.
     * @param  {boolean}      [sync=false]       If the refresh needs syncing.
     * @param  {boolean}      [showErrors=false] Wether to show errors to the user or hide them.
     * @return {Promise<any>} Promise resolved when done.
     */
    protected loadContent(refresh?: boolean, sync: boolean = false, showErrors: boolean = false): Promise<any> {
        this.isOnline = this.appProvider.isOnline();

        if (!this.module) {
            // This can happen if course format changes from single activity to weekly/topics.
            return Promise.resolve();
        }

        // Wrap the call in a try/catch so the workflow isn't interrupted if an error occurs.
        // E.g. when changing course format we cannot know when will this.module become undefined, so it could cause errors.
        let promise;

        try {
            promise = this.fetchContent(refresh, sync, showErrors);
        } catch (ex) {
            // An error ocurred in the function, log the error and just resolve the promise so the workflow continues.
            this.logger.error(ex);

            promise = Promise.resolve();
        }

        return promise.catch((error) => {
            if (!refresh) {
                // Some call failed, retry without using cache since it might be a new activity.
                return this.refreshContent(sync);
            }

            // Error getting data, fail.
            this.domUtils.showErrorModalDefault(error, this.fetchContentDefaultError, true);
        }).finally(() => {
            this.loaded = true;
            this.refreshIcon = 'refresh';
            this.syncIcon = 'sync';
        });
    }

    /**
     * Get the current badge count visible when the app is not running
     * successHandler gets called with an integer which is the current badge count
     */
    getApplicationIconBadgeNumber(): Promise<number> {
        if (!this.appProvider.isDesktop()) {
            return Promise.reject('getApplicationIconBadgeNumber is not supported in browser');
        }

        try {
            const app = require('electron').remote.app;

            return Promise.resolve(app.getBadgeCount());
        } catch (ex) {
            return Promise.reject(ex);
        }
    }

    /**
     * Open an file.
     *
     * @param {string} filePath File path.
     * @param {string} fileMIMEType File MIME type.
     * @returns {Promise<any>} Promise resolved when done.
     */
    open(filePath: string, fileMIMEType: string): Promise<any> {
        if (this.appProvider.isDesktop()) {
            // It's a desktop app, send an event so the file is opened.
            // Opening the file from here (renderer process) doesn't focus the opened app, that's why an event is needed.
            // Use sendSync so we can receive the result.
            if (!require('electron').ipcRenderer.sendSync('openItem', filePath)) {
                return Promise.reject('Error opening file');
            }
        } else {
            window.open(filePath, '_blank');
        }

        return Promise.resolve();
    }

    /**
     * Opens a URL in a new InAppBrowser instance, the current browser instance, or the system browser.
     *
     * @param {string} url The URL to load.
     * @param {string} [target] The target in which to load the URL, an optional parameter that defaults to _self.
     * @param {string} [options] Options for the InAppBrowser.
     * @return {any} The new instance.
     */
    create(url: string, target?: string, options: string = 'location=yes'): any {
        if (options && typeof options !== 'string') {
            // Convert to string.
            options = Object.keys(options).map((key) => {
                return key + '=' + options[key];
            }).join(',');
        }

        if (!this.appProvider.isDesktop()) {
            return super.create(url, target, options);
        }

        return new InAppBrowserObjectMock(this.appProvider, this.fileProvider, this.urlUtils, url, target, options);
    }

    /**
     * Add a new attachment.
     */
    add(): void {
        const allowOffline = this.allowOffline && this.allowOffline !== 'false';

        if (!allowOffline && !this.appProvider.isOnline()) {
            this.domUtils.showErrorModal('core.fileuploader.errormustbeonlinetoupload', true);
        } else {
            const mimetypes = this.fileTypes && this.fileTypes.mimetypes;

            this.fileUploaderHelper.selectFile(this.maxSize, allowOffline, undefined, mimetypes).then((result) => {
                this.files.push(result);
            }).catch((error) => {
                this.domUtils.showErrorModalDefault(error, 'Error selecting file.');
            });
        }
    }

    /**
     * Set the badge count visible when the app is not running
     *
     * The count is an integer indicating what number should show up in the badge.
     * Passing 0 will clear the badge.
     * Each notification event contains a data.count value which can be used to set the badge to correct number.
     *
     * @param count
     */
    setApplicationIconBadgeNumber(count?: number): Promise<any> {
        if (!this.appProvider.isDesktop()) {
            return Promise.reject('setApplicationIconBadgeNumber is not supported in browser');
        }

        try {
            const app = require('electron').remote.app;
            if (app.setBadgeCount(count)) {
                return Promise.resolve();
            } else {
                return Promise.reject(null);
            }
        } catch (ex) {
            return Promise.reject(ex);
        }
    }