iobroker.google-sharedlocations2 0.0.2 → 0.1.0

package/README.md

@@ -27,6 +27,15 @@ Copyright and trademark of Google are property of Google.
     Placeholder for the next version (at the beginning of the line):
     ### **WORK IN PROGRESS**
 -->
+### 0.1.0 (2026-02-02)
+* (Garfonso) added: support for places
+* (Garfonso) added: support for fences
+* (Garfonso) try to prevent login as much as possible.
+
+### 0.0.3 (2026-01-28)
+* (Garfonso) prevent login if no username and password is set
+* (Garfonso) fix tests
+
 ### 0.0.2 (2026-01-28)
 * (Garfonso) store password encrypted
 

package/admin/jsonConfig.json

@@ -1,51 +1,135 @@
 {
     "i18n": true,
-    "type": "panel",
-    "items": {
-        "_explanation": {
-            "type": "staticText",
-            "label": "Please provide the credentials of an ioBroker Google Account which you share your location with using the Google Maps App. It is strongly recommended to create a dedicated Google Account for this purpose.",
-            "newLine": true,
-            "xs": 12,
-            "sm": 12,
-            "md": 12,
-            "lg": 12,
-            "xl": 12
+    "type": "tabs",
+    "items": [
+        {
+            "type": "panel",
+            "label": "Google Settings",
+            "items": {
+                "_explanation": {
+                    "type": "staticText",
+                    "label": "Please provide the credentials of an ioBroker Google Account which you share your location with using the Google Maps App. It is strongly recommended to create a dedicated Google Account for this purpose.",
+                    "newLine": true,
+                    "xs": 12,
+                    "sm": 12,
+                    "md": 12,
+                    "lg": 12,
+                    "xl": 12
+                },
+                "googleUsername": {
+                    "type": "text",
+                    "label": "Username of ioBroker Google Account",
+                    "newLine": true,
+                    "xs": 12,
+                    "sm": 12,
+                    "md": 6,
+                    "lg": 6,
+                    "xl": 6
+                },
+                "googlePassword": {
+                    "type": "password",
+                    "label": "Password of ioBroker Google Account",
+                    "visible": true,
+                    "xs": 12,
+                    "sm": 12,
+                    "md": 6,
+                    "lg": 6,
+                    "xl": 6
+                },
+                "pollInterval": {
+                    "type": "number",
+                    "label": "Polling Interval (in seconds, at least 60 seconds)",
+                    "default": 300,
+                    "unit": "s",
+                    "min": 60,
+                    "max": 86400,
+                    "step": 10,
+                    "newLine": true,
+                    "xs": 12,
+                    "sm": 12,
+                    "md": 6,
+                    "lg": 6,
+                    "xl": 6
+                }
+            }
         },
-        "googleUsername": {
-            "type": "text",
-            "label": "Username of ioBroker Google Account",
-            "newLine": true,
-            "xs": 12,
-            "sm": 12,
-            "md": 6,
-            "lg": 6,
-            "xl": 6
-        },
-        "googlePassword": {
-            "type": "password",
-            "label": "Password of ioBroker Google Account",
-            "visible": true,
-            "xs": 12,
-            "sm": 12,
-            "md": 6,
-            "lg": 6,
-            "xl": 6
-        },
-        "pollInterval": {
-            "type": "number",
-            "label": "Polling Interval (in seconds, at least 60 seconds)",
-            "default": 300,
-            "unit": "s",
-            "min": 60,
-            "max": 86400,
-            "step": 10,
-            "newLine": true,
-            "xs": 12,
-            "sm": 12,
-            "md": 6,
-            "lg": 6,
-            "xl": 6
+        {
+            "type": "panel",
+            "label": "Geofencing Settings",
+            "items": {
+                "placesInstance": {
+                    "type": "instance",
+                    "label": "Instance of iobroker.places to use (set to -1 to auto-detect)",
+                    "adapter": "places",
+                    "allowDeactivate": true,
+                    "newLine": true,
+                    "xs": 12,
+                    "sm": 12,
+                    "md": 6,
+                    "lg": 6,
+                    "xl": 6
+                },
+                "fences": {
+                    "type": "table",
+                    "clone": false,
+                    "newLine": true,
+                    "xs": 12,
+                    "sm": 12,
+                    "md": 12,
+                    "lg": 12,
+                    "xl": 12,
+                    "label": "Fences, will create boolean states for each fence to indicate if user is within the fence",
+                    "items": [
+                        {
+                            "type": "text",
+                            "title": "Name of fence",
+                            "width": "20%",
+                            "attr": "name",
+                            "sort": true,
+                            "default": ""
+                        },
+                        {
+                            "type": "number",
+                            "title": "Latitude",
+                            "width": "20%",
+                            "attr": "latitude"
+                        },
+                        {
+                            "type": "number",
+                            "title": "Longitude",
+                            "width": "20%",
+                            "attr": "longitude"
+                        },
+                        {
+                            "type": "number",
+                            "title": "Radius (m)",
+                            "width": "5%",
+                            "attr": "radius",
+                            "default": 100
+                        },
+                        {
+                            "type": "selectSendTo",
+                            "command": "getUsers",
+                            "attr": "user",
+                            "multiple": false,
+                            "title": "Users",
+                            "width": "20%",
+                            "default": ""
+                        },
+                        {
+                            "type": "text",
+                            "title": "Fence ID",
+                            "width": "15%",
+                            "attr": "fenceId",
+                            "defaultFunc": "data.name + data.user",
+                            "alsoDependsOn": [
+                                "name",
+                                "user"
+                            ]
+                        }
+                    ]
+                }
+            }
         }
-    }
-}
+    ]
+}

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "google-sharedlocations2",
-    "version": "0.0.2",
+    "version": "0.1.0",
     "news": {
+      "0.1.0": {
+        "en": "added: support for places\nadded: support for fences\ntry to prevent login as much as possible.",
+        "de": "hinzugefügt: unterstützung für places\nhinzugefügt: unterstützung für fences\nversuche, die anmeldung so weit wie möglich zu verhindern.",
+        "ru": "добавлено: поддержка мест\nдобавлено: поддержка заборов\nстарайтесь максимально предотвратить вход.",
+        "pt": "adicionado: suporte para locais\nadicionado: suporte para cercas\ntentar evitar o login o máximo possível.",
+        "nl": "toegevoegd: ondersteuning voor plaatsen\ntoegevoegd: steun voor hekken\nproberen zo veel mogelijk inloggen te voorkomen.",
+        "fr": "ajouté: soutien aux places\najouté: soutien aux clôtures\nessayer d'éviter la connexion autant que possible.",
+        "it": "aggiunto: supporto per i luoghi\naggiunto: supporto per recinzioni\ncercare di impedire il login il più possibile.",
+        "es": "añadido: apoyo a los lugares\nañadido: soporte para vallas\ntratar de prevenir la entrada tanto como sea posible.",
+        "pl": "dodane: wsparcie dla miejsc\ndodane: wsparcie dla ogrodzeń\nspróbuj zapobiec logowaniu jak najwięcej.",
+        "uk": "додано: підтримка місць\nдоданий: підтримка парканів\nнамагатися попередити логін якомога простіше.",
+        "zh-cn": "添加:对位置的支持\n添加:支持围栏\n尽量防止登录."
+      },
+      "0.0.3": {
+        "en": "prevent login if no username and password is set\nfix tests",
+        "de": "verhindern login, wenn kein benutzername und passwort eingestellt ist\ntests repariert",
+        "ru": "предотвратить вход в систему, если имя пользователя и пароль не установлены\nисправление",
+        "pt": "impedir o login se nenhum nome de usuário e senha estiver definido\ncorrigir os testes",
+        "nl": "login voorkomen als er geen gebruikersnaam en wachtwoord is ingesteld\nvastleggen van tests",
+        "fr": "empêcher le login si aucun nom d'utilisateur et mot de passe n'est défini\nessais de correction",
+        "it": "impedire il login se non viene impostato nessun nome utente e password\ntest di correzione",
+        "es": "previene el inicio de sesión si no se establece el nombre de usuario y la contraseña\npruebas de reparación",
+        "pl": "zapobiec logowaniu, jeśli nie jest ustawiona nazwa użytkownika i hasło\nbadania naprawcze",
+        "uk": "заборонити логін, якщо не встановлено ім’я користувача та пароль\nфіксувати тести",
+        "zh-cn": "如果没有设置用户名和密码, 请防止登录\n固定测试"
+      },
       "0.0.2": {
         "en": "store password encrypted",
         "de": "speicher passwort verschlüsselt",
@@ -82,6 +108,7 @@
     "compact": true,
     "connectionType": "cloud",
     "dataSource": "poll",
+    "messagebox": true,
     "adminUI": {
       "config": "json"
     },
@@ -140,7 +167,9 @@
   "native": {
     "googleUsername": "",
     "googlePassword": "",
-    "pollInterval": 60
+    "pollInterval": 60,
+    "placesInstance": "",
+    "fences": []
   },
   "protectedNative": [
     "googlePassword"
@@ -184,6 +213,15 @@
         "def": ""
       }
     },
+    {
+      "_id": "fences",
+      "type": "folder",
+      "common": {
+        "name": "Geofences",
+        "desc": "States for fences defined in the config."
+      },
+      "native": {}
+    },
     {
       "_id": "users",
       "type": "folder",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.google-sharedlocations2",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "Share your location with iobroker via google maps.",
   "author": {
     "name": "Garfonso",

package/src/lib/Cookie.ts

@@ -0,0 +1,220 @@
+import axios from 'axios';
+import type { GoogleSharedlocations2 } from '../main';
+import puppeteer from 'puppeteer';
+import type { Browser } from 'puppeteer';
+
+/**
+ * Helper class to manage Google cookies.
+ */
+export class Cookie {
+    currentCookie: string;
+    username?: string;
+    password?: string;
+    adapter: GoogleSharedlocations2;
+    log;
+    private browser: Browser | null = null;
+
+    /**
+     * Construct cookie helper
+     *
+     * @param adapter - adapter instance
+     */
+    constructor(adapter: GoogleSharedlocations2) {
+        this.currentCookie = '';
+        this.username = '';
+        this.password = '';
+        this.adapter = adapter;
+        this.log = adapter.log;
+    }
+
+    /**
+     * Initialize the cookie helper by loading the cookie from state.
+     */
+    async init(): Promise<void> {
+        this.username = this.adapter.config.googleUsername;
+        this.password = this.adapter.config.googlePassword;
+        try {
+            const state = await this.adapter.getStateAsync('info.currentCookies');
+            if (state && state.val && typeof state.val === 'string') {
+                this.currentCookie = state.val;
+                this.log?.debug('Loaded cookie from state.');
+            } else {
+                this.currentCookie = '';
+                this.log?.debug('No cookie found in state, trying to log in to get new one.');
+                await this.loginToGetNewCookies();
+            }
+        } catch (err: any) {
+            this.log?.error(`Error loading cookie from state: ${err}`);
+        }
+    }
+
+    /**
+     * Store the current cookie in an iobroker state.
+     */
+    async storeCookie(): Promise<void> {
+        try {
+            await this.adapter.setStateAsync('info.currentCookies', this.currentCookie, true);
+        } catch (err: any) {
+            this.log?.error(`Error storing cookie: ${err}`);
+        }
+    }
+
+    /**
+     * Augment the current cookie with data from the 'set-cookie' header.
+     *
+     * @param headers - HTTP headers of axios response
+     */
+    async augmentCookieFromHeader(headers: Record<string, any>): Promise<void> {
+        if (headers['set-cookie'] && headers['set-cookie'].length) {
+            this.log?.debug('New header received.');
+            const oldLength = this.currentCookie.length;
+            const cookies = this.currentCookie.split('; ').map(c => c.split('='));
+
+            //split old cookie and new cookie. Update single values.
+            for (const header of headers['set-cookie']) {
+                const incomingCookies = header.split('; ');
+                for (const cookie of incomingCookies) {
+                    const [name, value] = cookie.split('=');
+                    const cIndex = cookies.findIndex(c => c[0] === name);
+                    if (cIndex < 0) {
+                        cookies.push([name, value]); //add
+                    } else {
+                        cookies[cIndex][1] = value; //update
+                    }
+                }
+            }
+
+            this.currentCookie = cookies.map(cv => cv.join('=')).join('; ');
+            this.log?.debug(`Cookie updated. Length: ${oldLength} -> ${this.currentCookie.length}`);
+            return this.storeCookie();
+        }
+    }
+
+    /**
+     * Improve the current cookie by making a request to Google My Account page.
+     */
+    async improveCookie(): Promise<void> {
+        //see https://github.com/costastf/locationsharinglib/blob/master/locationsharinglib/locationsharinglib.py#L105
+        const options = {
+            url: 'https://myaccount.google.com/?hl=en',
+            headers: {
+                Cookie: this.currentCookie,
+            },
+            method: 'get',
+        };
+
+        try {
+            const response = await axios(options);
+
+            if (response.status !== 200) {
+                this.log?.error(`Failed improving cookie: ${response.status}`);
+            } else {
+                await this.augmentCookieFromHeader(response.headers);
+            }
+        } catch (err: any) {
+            this.log?.error(err);
+            this.log?.info('Connection to google maps failure.');
+        }
+    }
+
+    /**
+     * Login to Google using puppeteer to get new cookies.
+     */
+    async loginToGetNewCookies(): Promise<boolean> {
+        try {
+            if (this.browser) {
+                this.log.info('Seems we are already trying to log in. Aborting new login attempt.');
+                return false;
+            }
+            if (!this.username || !this.password) {
+                this.log.warn('Google username or password not set in adapter configuration. Can not login.');
+                return false;
+            }
+
+            this.log.info('Trying to login to Google to get new cookies.');
+            //testing puppeteer:
+            this.log.debug('Starting browser.');
+            this.browser = await puppeteer.launch({
+                headless: true,
+                args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-blink-features=AutomationControlled'],
+                ignoreDefaultArgs: ['--enable-automation'], //hide automation flag, did not help.
+            });
+            this.log.debug('browser started, opening new page.');
+            const page = await this.browser.newPage();
+
+            //hide puppeteer automation flag
+            await page.evaluateOnNewDocument(() => {
+                Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            });
+            await page.setUserAgent({
+                userAgent:
+                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            });
+
+            this.log.debug('going to google login page.');
+            await page.goto(
+                'https://accounts.google.com/ServiceLogin?hl=de&continue=https://www.google.com/maps&gae=cb-eomtm',
+                {
+                    waitUntil: 'networkidle2',
+                    timeout: 60000,
+                },
+            );
+
+            this.log.debug('filling in username and clicking next.');
+            await page.locator('#identifierId').fill(this.username);
+            //is this enough, or do we need to search button in this div?
+            await page.locator('#identifierNext').click();
+            //waiting for #password fails in headles.. :-(
+            await page.waitForNetworkIdle({ idleTime: 2000 });
+
+            this.log.debug('filling in password and clicking next.');
+            //do we need to  wait until page is loaded / rendered here?
+            await page.locator('input[type="password"]').fill(this.password);
+            this.log.debug('clicking password next button.');
+            await page.locator('#passwordNext').click();
+            //await page.waitForNetworkIdle({ idleTime: 2000 }); -> does never happen in headless.. :-/
+            await new Promise(resolve => setTimeout(resolve, 3000));
+
+            await page.goto('https://www.google.com/maps');
+            this.log.debug('getting cookies.');
+            //using deprecated function, but browser.cookies just does not work...???
+            const cookies = await page.cookies();
+
+            this.currentCookie = cookies
+                .filter(c => c.domain.includes('google'))
+                .map(c => `${c.name}=${c.value}`)
+                .join('; ');
+            //this.log.debug(this._cookies);
+            //console.log(this._cookies);
+            await this.browser.close();
+            if (this.currentCookie.length < 50) {
+                this.log.warn('Cookie string seems too short, login probably failed!');
+            } else {
+                this.log.info('Obtained new cookies from Google login.');
+                await this.storeCookie();
+            }
+            this.browser = null;
+            return true;
+        } catch (e) {
+            this.log.error(`Error in puppeteer: ${(e as Error).message}`);
+        }
+        return false;
+    }
+
+    /**
+     * Clean up on unload.
+     */
+    async cleanUp(): Promise<void> {
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+        }
+    }
+
+    /**
+     * Check if the current cookie is valid.
+     */
+    isValid(): boolean {
+        return this.currentCookie.length > 50;
+    }
+}

package/src/lib/Fence.ts

@@ -0,0 +1,62 @@
+import type { User } from './User';
+
+/**
+ * Geofence class
+ */
+export class Fence {
+    name: string;
+    lat: number;
+    long: number;
+    radius: number;
+    user: string;
+    fenceId: string;
+    valid: boolean = true;
+
+    /**
+     * Constructor
+     *
+     * @param name of the fence
+     * @param lat of the fence center
+     * @param long of the fence center
+     * @param radius in meters
+     * @param user user id to check
+     * @param fenceId iobroker state id to set
+     */
+    constructor(name: string, lat: number, long: number, radius: number, user: string, fenceId: string) {
+        this.name = name;
+        this.lat = lat;
+        this.long = long;
+        this.radius = radius;
+        this.user = user;
+        this.fenceId = fenceId;
+        this.valid = !!(lat && long && radius > 0 && user && fenceId);
+    }
+
+    private toRadians(degrees: number): number {
+        return degrees * (Math.PI / 180);
+    }
+
+    private haversineDistance(lat1: number, lon1: number, lat2: number, lon2: number): number {
+        const R = 6371000; // Earth radius in meters
+        const dLat = this.toRadians(lat2 - lat1);
+        const dLon = this.toRadians(lon2 - lon1);
+        const a =
+            Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+            Math.cos(this.toRadians(lat1)) * Math.cos(this.toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return R * c;
+    }
+
+    /**
+     * Check if a point is inside the fence.
+     *
+     * @param user to check
+     */
+    isInsideFence(user: User): boolean {
+        if (this.valid && user.id && user.lat && user.long) {
+            const distance = this.haversineDistance(this.lat, this.long, user.lat, user.long);
+            return distance <= this.radius;
+        }
+        return false;
+    }
+}

package/src/lib/User.ts

@@ -0,0 +1,53 @@
+/**
+ * User class representing a user with location and info data.
+ */
+export class User {
+    id: string | null;
+    name?: string;
+    photoURL?: string;
+    lat?: number;
+    long?: number;
+    address?: string;
+    battery?: number;
+    timestamp?: number;
+    accuracy?: number;
+
+    /**
+     * Creates a User instance from location data.
+     *
+     * @param locationData - Array containing user location and info data
+     */
+    constructor(locationData: Array<any>) {
+        this.id = null;
+        if (locationData && Array.isArray(locationData)) {
+            // locationData present
+            if (locationData[0] && locationData[0][0]) {
+                this.id = locationData[0][0];
+            }
+            if (locationData[0] && locationData[0][1]) {
+                this.photoURL = locationData[0][1];
+            }
+            if (locationData[0] && locationData[0][3]) {
+                this.name = locationData[0][3];
+            }
+            if (locationData[1] && locationData[1][1] && locationData[1][1][2]) {
+                this.lat = locationData[1][1][2];
+            }
+            if (locationData[1] && locationData[1][1] && locationData[1][1][1]) {
+                this.long = locationData[1][1][1];
+            }
+            if (locationData[1] && locationData[1][4]) {
+                this.address = locationData[1][4];
+            }
+            if (locationData[13] && locationData[13][1]) {
+                this.battery = locationData[13][1];
+            }
+            if (locationData[1] && locationData[1][2]) {
+                this.timestamp = locationData[1][2];
+            }
+            if (locationData[1] && locationData[1][3]) {
+                this.accuracy = locationData[1][3];
+            }
+        }
+    }
+}

package/src/lib/adapter-config.d.ts

@@ -7,6 +7,15 @@ declare global {
             googleUsername: string;
             googlePassword: string;
             pollInterval: number;
+            placesInstance: string;
+            fences: Array<{
+                name: string;
+                latitude: number;
+                longitude: number;
+                radius: number;
+                user: string;
+                fenceId: string;
+            }>;
         }
     }
 }

package/src/main.ts

@@ -6,7 +6,9 @@
 // you need to create an adapter
 import * as utils from '@iobroker/adapter-core';
 
-import puppeteer, { type Browser } from 'puppeteer';
+import { User } from './lib/User';
+import { Fence } from './lib/Fence';
+import { Cookie } from './lib/Cookie';
 import axios from 'axios';
 
 //used to test timeout against
@@ -15,13 +17,22 @@ const MAX_INT32 = 2 ** 31 - 1; // 2147483647 (hex 0x7FFFFFFF)
 // Load your modules here, e.g.:
 // import * as fs from 'fs';
 
-class GoogleSharedlocations2 extends utils.Adapter {
-    _cookies: string | null = null;
+/**
+ * The adapter class
+ */
+export class GoogleSharedlocations2 extends utils.Adapter {
     _pollTimeout: ioBroker.Timeout | undefined;
     _pollInterval: number = 300;
     _successFullPolls: number = 1; // let us try a relogin at start, if cookie does not work.
-    _browser: Browser | null = null;
+    _users: Record<string, User> = {};
+    fences: Fence[] = [];
+    cookie: Cookie;
 
+    /**
+     * Creates an instance of the adapter.
+     *
+     * @param options - adapter options
+     */
     public constructor(options: Partial<utils.AdapterOptions> = {}) {
         super({
             ...options,
@@ -30,8 +41,9 @@ class GoogleSharedlocations2 extends utils.Adapter {
         this.on('ready', this.onReady.bind(this));
         this.on('stateChange', this.onStateChange.bind(this));
         // this.on('objectChange', this.onObjectChange.bind(this));
-        // this.on('message', this.onMessage.bind(this));
+        this.on('message', this.onMessage.bind(this));
         this.on('unload', this.onUnload.bind(this));
+        this.cookie = new Cookie(this);
     }
 
     /**
@@ -42,15 +54,7 @@ class GoogleSharedlocations2 extends utils.Adapter {
 
         // Reset the connection indicator during startup
         await this.setState('info.connection', false, true);
-        this._cookies = ((await this.getStateAsync('info.currentCookies'))?.val as string) || null;
-        if (!this._cookies) {
-            if (!this.config.googleUsername || !this.config.googlePassword) {
-                this.log.error('Google username or password not set in adapter configuration!');
-                return;
-            }
-            await this.loginToGetNewCookies();
-        }
-
+        await this.cookie.init();
         await this.subscribeStatesAsync('info.currentCookies');
 
         //sanitize polling interval:
@@ -65,20 +69,67 @@ class GoogleSharedlocations2 extends utils.Adapter {
             this._pollInterval = MAX_INT32;
         }
 
+        //read fences:
+        for (const fenceConfig of this.config.fences || []) {
+            const fence = new Fence(
+                fenceConfig.name,
+                fenceConfig.latitude,
+                fenceConfig.longitude,
+                fenceConfig.radius,
+                fenceConfig.user,
+                fenceConfig.fenceId,
+            );
+            if (fence.valid) {
+                this.fences.push(fence);
+                await this.setObjectNotExistsAsync(`fences.${fence.fenceId}`, {
+                    type: 'state',
+                    common: {
+                        name: `${fence.name}`,
+                        type: 'boolean',
+                        read: true,
+                        write: false,
+                        role: 'sensor',
+                    },
+                    native: {},
+                });
+            } else {
+                this.log.warn(`Fence ${fenceConfig.name} is not valid and will be ignored.`);
+            }
+        }
+        //clear old fences:
+        const adapterObjects = await this.getAdapterObjectsAsync();
+        for (const objId of Object.keys(adapterObjects)) {
+            if (objId.startsWith(`${this.namespace}.fences.`) || objId.startsWith('fences.')) {
+                const fenceId = objId.split('.').pop() || '';
+                const found = this.fences.find(f => f.fenceId === fenceId);
+                if (!found) {
+                    this.log.info(`Deleting old fence state ${objId} as it is not in configuration anymore.`);
+                    await this.delObjectAsync(objId);
+                }
+            }
+        }
+
         //start polling positions
         this.pollPositions();
-        if (this._cookies) {
+        if (this.cookie.isValid()) {
             await this.sendRequest();
         }
     }
 
     private pollPositions(): void {
         this._pollTimeout = this.setTimeout(async () => {
-            if (!this._cookies) {
+            if (!this.cookie.isValid()) {
                 this.log.debug('Cannot poll positions, no cookies available!');
             } else {
                 this.log.debug('Polling positions with current cookies.');
+                const lastSuccessPolls = this._successFullPolls;
                 await this.sendRequest();
+                if (this._successFullPolls > 0 && lastSuccessPolls !== this._successFullPolls) {
+                    if (this._successFullPolls % 10 === 0) {
+                        //try to get some more headers from google:
+                        await this.cookie.improveCookie();
+                    }
+                }
             }
             //schedule next poll
             return this.pollPositions();
@@ -86,7 +137,7 @@ class GoogleSharedlocations2 extends utils.Adapter {
     }
 
     private async sendRequest(): Promise<void> {
-        if (!this._cookies) {
+        if (!this.cookie.isValid()) {
             this.log.error('Cannot send request, no cookies available!');
             await this.setState('info.connection', false, true);
             return;
@@ -98,7 +149,7 @@ class GoogleSharedlocations2 extends utils.Adapter {
             method: 'GET',
             url: 'https://www.google.com/maps/rpc/locationsharing/read',
             headers: {
-                Cookie: this._cookies,
+                Cookie: this.cookie.currentCookie,
             },
             params: {
                 authuser: 2,
@@ -119,71 +170,36 @@ class GoogleSharedlocations2 extends utils.Adapter {
                 this._successFullPolls += 1;
                 await this.setState('info.connection', true, true);
                 for (const location of locations) {
-                    await this.fillIntoObjects(location);
+                    const user = new User(location);
+                    if (user.id) {
+                        this._users[user.id] = user;
+                        await this.fillIntoObjects(user);
+                        await this.notifyPlaces(user);
+                        await this.checkFences(user);
+                    }
                 }
             } else {
                 this.log.info('No shared locations found in the response, probably not logged in.');
                 if (this._successFullPolls > 0) {
                     //try to get new cookie:
-                    await this.loginToGetNewCookies();
+                    this._successFullPolls = 0;
+                    await this.cookie.loginToGetNewCookies();
                 }
             }
         } catch (e) {
             this.log.error(`Error during request: ${(e as Error).message}`);
             if (this._successFullPolls > 0) {
                 //try to get new cookie:
-                await this.loginToGetNewCookies();
+                this._successFullPolls = 0;
+                await this.cookie.loginToGetNewCookies();
             }
         }
     }
 
-    private async fillIntoObjects(locationData: any): Promise<void> {
+    private async fillIntoObjects(user: User): Promise<void> {
         try {
-            const user = {
-                id: undefined,
-                photoURL: undefined,
-                name: undefined,
-                lat: undefined,
-                long: undefined,
-                address: undefined,
-                battery: undefined,
-                timestamp: undefined,
-                accuracy: undefined,
-            };
-
-            if (locationData && Array.isArray(locationData)) {
-                // locationData present
-                if (locationData[0] && locationData[0][0]) {
-                    user.id = locationData[0][0];
-                }
-                if (locationData[0] && locationData[0][1]) {
-                    user.photoURL = locationData[0][1];
-                }
-                if (locationData[0] && locationData[0][3]) {
-                    user.name = locationData[0][3];
-                }
-                if (locationData[1] && locationData[1][1] && locationData[1][1][2]) {
-                    user.lat = locationData[1][1][2];
-                }
-                if (locationData[1] && locationData[1][1] && locationData[1][1][1]) {
-                    user.long = locationData[1][1][1];
-                }
-                if (locationData[1] && locationData[1][4]) {
-                    user.address = locationData[1][4];
-                }
-                if (locationData[13] && locationData[13][1]) {
-                    user.battery = locationData[13][1];
-                }
-                if (locationData[1] && locationData[1][2]) {
-                    user.timestamp = locationData[1][2];
-                }
-                if (locationData[1] && locationData[1][3]) {
-                    user.accuracy = locationData[1][3];
-                }
-            }
-
             if (user.id) {
-                const basepath = `users.${user.id as string}`;
+                const basepath = `users.${user.id}`;
                 const deviceObj = {
                     _id: basepath,
                     type: 'device',
@@ -306,79 +322,28 @@ class GoogleSharedlocations2 extends utils.Adapter {
         }
     }
 
-    private async loginToGetNewCookies(): Promise<void> {
-        try {
-            if (this._browser) {
-                this.log.info('Seems we are already trying to log in. Aborting new login attempt.');
-                return;
-            }
-            this.log.info('Trying to login to Google to get new cookies.');
-            this._successFullPolls = 0;
-
-            //testing puppeteer:
-            this.log.debug('Starting browser.');
-            this._browser = await puppeteer.launch({
-                headless: true,
-                args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-blink-features=AutomationControlled'],
-                ignoreDefaultArgs: ['--enable-automation'], //hide automation flag, did not help.
+    private async notifyPlaces(user: User): Promise<void> {
+        if (this.config.placesInstance && user.id && user.lat && user.long) {
+            await this.sendToAsync(this.config.placesInstance, {
+                user: user.name,
+                latitude: user.lat,
+                longitude: user.long,
+                timestamp: user.timestamp || Date.now(),
+                address: user.address,
             });
-            this.log.debug('browser started, opening new page.');
-            const page = await this._browser.newPage();
-
-            //hide puppeteer automation flag
-            await page.evaluateOnNewDocument(() => {
-                Object.defineProperty(navigator, 'webdriver', { get: () => false });
-            });
-            await page.setUserAgent({
-                userAgent:
-                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            });
-
-            this.log.debug('going to google login page.');
-            await page.goto(
-                'https://accounts.google.com/ServiceLogin?hl=de&continue=https://www.google.com/maps&gae=cb-eomtm',
-                {
-                    waitUntil: 'networkidle2',
-                    timeout: 60000,
-                },
-            );
-
-            this.log.debug('filling in username and clicking next.');
-            await page.locator('#identifierId').fill(this.config.googleUsername);
-            //is this enough, or do we need to search button in this div?
-            await page.locator('#identifierNext').click();
-            //waiting for #password fails in headles.. :-(
-            await page.waitForNetworkIdle({ idleTime: 2000 });
-
-            this.log.debug('filling in password and clicking next.');
-            //do we need to  wait until page is loaded / rendered here?
-            await page.locator('input[type="password"]').fill(this.config.googlePassword);
-            this.log.debug('clicking password next button.');
-            await page.locator('#passwordNext').click();
-            //await page.waitForNetworkIdle({ idleTime: 2000 }); -> does never happen in headless.. :-/
-            await new Promise(resolve => setTimeout(resolve, 3000));
-
-            await page.goto('https://www.google.com/maps');
-            this.log.debug('getting cookies.');
-            //using deprecated function, but browser.cookies just does not work...???
-            const cookies = await page.cookies();
+        }
+    }
 
-            this._cookies = cookies
-                .filter(c => c.domain.includes('google'))
-                .map(c => `${c.name}=${c.value}`)
-                .join('; ');
-            //this.log.debug(this._cookies);
-            //console.log(this._cookies);
-            await this._browser.close();
-            if (this._cookies.length < 50) {
-                this.log.warn('Cookie string seems too short, login probably failed!');
-            } else {
-                this.log.info('Obtained new cookies from Google login.');
-                await this.setState('info.currentCookies', { val: this._cookies, ack: true });
+    private async checkFences(user: User): Promise<void> {
+        for (const fence of this.fences) {
+            if (fence.valid && fence.user === user.id) {
+                const inside = fence.isInsideFence(user);
+                await this.setStateChangedAsync(`fences.${fence.fenceId}`, {
+                    val: inside,
+                    ts: user.timestamp,
+                    ack: true,
+                });
             }
-            this._browser = null;
-        } catch (e) {
-            this.log.error(`Error in puppeteer: ${(e as Error).message}`);
         }
     }
 
@@ -387,7 +352,7 @@ class GoogleSharedlocations2 extends utils.Adapter {
      *
      * @param callback - Callback function
      */
-    private onUnload(callback: () => void): void {
+    private async onUnload(callback: () => void): Promise<void> {
         try {
             // Here you must clear all timeouts or intervals that may still be active
             // clearTimeout(timeout1);
@@ -397,13 +362,7 @@ class GoogleSharedlocations2 extends utils.Adapter {
             if (this._pollTimeout) {
                 clearTimeout(this._pollTimeout);
             }
-            if (this._browser) {
-                //ignore results here.
-                this._browser
-                    .close()
-                    .then(() => {})
-                    .catch(() => {});
-            }
+            await this.cookie.cleanUp();
             callback();
         } catch (error) {
             this.log.error(`Error during unloading: ${(error as Error).message}`);
@@ -436,35 +395,46 @@ class GoogleSharedlocations2 extends utils.Adapter {
         if (id.endsWith('info.currentCookies') && state && !state.ack) {
             if (state.val === '') {
                 this.log.info('Current cookies state was cleared, trying to obtain new cookies.');
-                this._cookies = null;
-                await this.loginToGetNewCookies();
-                if (this._cookies) {
+                this._successFullPolls = 0;
+                await this.cookie.loginToGetNewCookies();
+                if (this.cookie.isValid()) {
                     await this.sendRequest();
                 }
             } else {
                 this.log.info(
                     'Current cookies state was changed from outside the adapter, updating internal cookie store.',
                 );
-                this._cookies = state.val as string;
+                this.cookie.currentCookie = state.val as string;
+            }
+        }
+    }
+
+    /**
+     * Some message was sent to this instance over message box. Used by email, pushover, text2speech, ...
+     * Using this method requires "common.messagebox" property to be set to true in io-package.json
+     *
+     * @param obj - message object
+     */
+    private onMessage(obj: ioBroker.Message): void {
+        this.log.debug(`Received ${obj?.command} message`);
+        if (obj?.command === 'getUsers') {
+            this.log.debug('Received getUsers message');
+            // Send response in callback if required
+            if (obj.callback) {
+                try {
+                    const result = Object.values(this._users).map(user => ({
+                        value: user.id,
+                        label: user.name || user.id,
+                    }));
+                    this.log.debug(`Result: ${JSON.stringify(result)}`);
+                    this.sendTo(obj.from, obj.command, result, obj.callback);
+                } catch (e) {
+                    this.log.error(`Error processing getUsers message: ${(e as Error).message}`);
+                    this.sendTo(obj.from, obj.command, [], obj.callback);
+                }
             }
         }
     }
-    // If you need to accept messages in your adapter, uncomment the following block and the corresponding line in the constructor.
-    // /**
-    //  * Some message was sent to this instance over message box. Used by email, pushover, text2speech, ...
-    //  * Using this method requires "common.messagebox" property to be set to true in io-package.json
-    //  */
-    //
-    // private onMessage(obj: ioBroker.Message): void {
-    //     if (typeof obj === 'object' && obj.message) {
-    //         if (obj.command === 'send') {
-    //             // e.g. send email or pushover or whatever
-    //             this.log.info('send command');
-    //             // Send response in callback if required
-    //             if (obj.callback) this.sendTo(obj.from, obj.command, 'Message received', obj.callback);
-    //         }
-    //     }
-    // }
 }
 //if (require.main !== module) {
 // Export the constructor in compact mode