flet-geolocator 0.1.0__tar.gz

flet_geolocator-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.2
+Name: flet-geolocator
+Version: 0.1.0
+Summary: Geolocator control for Flet
+Author-email: Flet contributors <hello@flet.dev>
+Project-URL: Homepage, https://flet.dev
+Project-URL: Documentation, https://flet.dev/docs/controls/geolocator
+Project-URL: Repository, https://github.com/flet-dev/flet-geolocator
+Project-URL: Issues, https://github.com/flet-dev/flet-geolocator/issues
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: flet>=0.25.2
+
+# Geolocator control for Flet
+
+`Geolocator` control for Flet.
+
+## Usage
+
+Add `flet-geolocator` as dependency (`pyproject.toml` or `requirements.txt`) to your Flet project.
+
+## Example
+
+```py
+
+import flet as ft
+
+import flet_geolocator as fg
+
+
+async def main(page: ft.Page):
+    page.scroll = ft.ScrollMode.ADAPTIVE
+    page.appbar = ft.AppBar(title=ft.Text("Geolocator Tests"))
+
+    def handle_position_change(e):
+        page.add(ft.Text(f"New position: {e.latitude} {e.longitude}"))
+
+    gl = fg.Geolocator(
+        location_settings=fg.GeolocatorSettings(
+            accuracy=fg.GeolocatorPositionAccuracy.LOW
+        ),
+        on_position_change=handle_position_change,
+        on_error=lambda e: page.add(ft.Text(f"Error: {e.data}")),
+    )
+    page.overlay.append(gl)
+
+    settings_dlg = lambda handler: ft.AlertDialog(
+        adaptive=True,
+        title=ft.Text("Opening Location Settings..."),
+        content=ft.Text(
+            "You are about to be redirected to the location/app settings. "
+            "Please locate this app and grant it location permissions."
+        ),
+        actions=[ft.TextButton(text="Take me there", on_click=handler)],
+        actions_alignment=ft.MainAxisAlignment.CENTER,
+    )
+
+    async def handle_permission_request(e):
+        p = await gl.request_permission_async(wait_timeout=60)
+        page.add(ft.Text(f"request_permission: {p}"))
+
+    async def handle_get_permission_status(e):
+        p = await gl.get_permission_status_async()
+        page.add(ft.Text(f"get_permission_status: {p}"))
+
+    async def handle_get_current_position(e):
+        p = await gl.get_current_position_async()
+        page.add(ft.Text(f"get_current_position: ({p.latitude}, {p.longitude})"))
+
+    async def handle_get_last_known_position(e):
+        p = await gl.get_last_known_position_async()
+        page.add(ft.Text(f"get_last_known_position: ({p.latitude}, {p.longitude})"))
+
+    async def handle_location_service_enabled(e):
+        p = await gl.is_location_service_enabled_async()
+        page.add(ft.Text(f"is_location_service_enabled: {p}"))
+
+    async def handle_open_location_settings(e):
+        p = await gl.open_location_settings_async()
+        page.close(location_settings_dlg)
+        page.add(ft.Text(f"open_location_settings: {p}"))
+
+    async def handle_open_app_settings(e):
+        p = await gl.open_app_settings_async()
+        page.close(app_settings_dlg)
+        page.add(ft.Text(f"open_app_settings: {p}"))
+
+    location_settings_dlg = settings_dlg(handle_open_location_settings)
+    app_settings_dlg = settings_dlg(handle_open_app_settings)
+
+    page.add(
+        ft.Row(
+            wrap=True,
+            controls=[
+                ft.OutlinedButton(
+                    "Request Permission",
+                    on_click=handle_permission_request,
+                ),
+                ft.OutlinedButton(
+                    "Get Permission Status",
+                    on_click=handle_get_permission_status,
+                ),
+                ft.OutlinedButton(
+                    "Get Current Position",
+                    on_click=handle_get_current_position,
+                ),
+                ft.OutlinedButton(
+                    "Get Last Known Position",
+                    visible=False if page.web else True,
+                    on_click=handle_get_last_known_position,
+                ),
+                ft.OutlinedButton(
+                    "Is Location Service Enabled",
+                    on_click=handle_location_service_enabled,
+                ),
+                ft.OutlinedButton(
+                    "Open Location Settings",
+                    visible=False if page.web else True,
+                    on_click=lambda e: page.open(location_settings_dlg),
+                ),
+                ft.OutlinedButton(
+                    "Open App Settings",
+                    visible=False if page.web else True,
+                    on_click=lambda e: page.open(app_settings_dlg),
+                ),
+            ],
+        )
+    )
+
+
+ft.app(main)
+```

flet_geolocator-0.1.0/README.md

@@ -0,0 +1,119 @@
+# Geolocator control for Flet
+
+`Geolocator` control for Flet.
+
+## Usage
+
+Add `flet-geolocator` as dependency (`pyproject.toml` or `requirements.txt`) to your Flet project.
+
+## Example
+
+```py
+
+import flet as ft
+
+import flet_geolocator as fg
+
+
+async def main(page: ft.Page):
+    page.scroll = ft.ScrollMode.ADAPTIVE
+    page.appbar = ft.AppBar(title=ft.Text("Geolocator Tests"))
+
+    def handle_position_change(e):
+        page.add(ft.Text(f"New position: {e.latitude} {e.longitude}"))
+
+    gl = fg.Geolocator(
+        location_settings=fg.GeolocatorSettings(
+            accuracy=fg.GeolocatorPositionAccuracy.LOW
+        ),
+        on_position_change=handle_position_change,
+        on_error=lambda e: page.add(ft.Text(f"Error: {e.data}")),
+    )
+    page.overlay.append(gl)
+
+    settings_dlg = lambda handler: ft.AlertDialog(
+        adaptive=True,
+        title=ft.Text("Opening Location Settings..."),
+        content=ft.Text(
+            "You are about to be redirected to the location/app settings. "
+            "Please locate this app and grant it location permissions."
+        ),
+        actions=[ft.TextButton(text="Take me there", on_click=handler)],
+        actions_alignment=ft.MainAxisAlignment.CENTER,
+    )
+
+    async def handle_permission_request(e):
+        p = await gl.request_permission_async(wait_timeout=60)
+        page.add(ft.Text(f"request_permission: {p}"))
+
+    async def handle_get_permission_status(e):
+        p = await gl.get_permission_status_async()
+        page.add(ft.Text(f"get_permission_status: {p}"))
+
+    async def handle_get_current_position(e):
+        p = await gl.get_current_position_async()
+        page.add(ft.Text(f"get_current_position: ({p.latitude}, {p.longitude})"))
+
+    async def handle_get_last_known_position(e):
+        p = await gl.get_last_known_position_async()
+        page.add(ft.Text(f"get_last_known_position: ({p.latitude}, {p.longitude})"))
+
+    async def handle_location_service_enabled(e):
+        p = await gl.is_location_service_enabled_async()
+        page.add(ft.Text(f"is_location_service_enabled: {p}"))
+
+    async def handle_open_location_settings(e):
+        p = await gl.open_location_settings_async()
+        page.close(location_settings_dlg)
+        page.add(ft.Text(f"open_location_settings: {p}"))
+
+    async def handle_open_app_settings(e):
+        p = await gl.open_app_settings_async()
+        page.close(app_settings_dlg)
+        page.add(ft.Text(f"open_app_settings: {p}"))
+
+    location_settings_dlg = settings_dlg(handle_open_location_settings)
+    app_settings_dlg = settings_dlg(handle_open_app_settings)
+
+    page.add(
+        ft.Row(
+            wrap=True,
+            controls=[
+                ft.OutlinedButton(
+                    "Request Permission",
+                    on_click=handle_permission_request,
+                ),
+                ft.OutlinedButton(
+                    "Get Permission Status",
+                    on_click=handle_get_permission_status,
+                ),
+                ft.OutlinedButton(
+                    "Get Current Position",
+                    on_click=handle_get_current_position,
+                ),
+                ft.OutlinedButton(
+                    "Get Last Known Position",
+                    visible=False if page.web else True,
+                    on_click=handle_get_last_known_position,
+                ),
+                ft.OutlinedButton(
+                    "Is Location Service Enabled",
+                    on_click=handle_location_service_enabled,
+                ),
+                ft.OutlinedButton(
+                    "Open Location Settings",
+                    visible=False if page.web else True,
+                    on_click=lambda e: page.open(location_settings_dlg),
+                ),
+                ft.OutlinedButton(
+                    "Open App Settings",
+                    visible=False if page.web else True,
+                    on_click=lambda e: page.open(app_settings_dlg),
+                ),
+            ],
+        )
+    )
+
+
+ft.app(main)
+```

flet_geolocator-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "flet-geolocator"
+version = "0.1.0"
+description = "Geolocator control for Flet"
+readme = "README.md"
+authors = [
+    { name = "Flet contributors", email = "hello@flet.dev" }
+]
+classifiers = [
+  "License :: OSI Approved :: Apache Software License",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "flet>=0.25.2",
+]
+
+[project.urls]
+Homepage = "https://flet.dev"
+Documentation = "https://flet.dev/docs/controls/geolocator"
+Repository = "https://github.com/flet-dev/flet-geolocator"
+Issues = "https://github.com/flet-dev/flet-geolocator/issues"
+
+[tool.setuptools.package-data]
+"flutter.flet_geolocator" = ["**/*"]
+
+[tool.uv]
+dev-dependencies = [
+    "flet[all]>=0.25.2",
+]
+
+[tool.setuptools]
+license-files = []
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

flet_geolocator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flet_geolocator-0.1.0/src/flet_geolocator/__init__.py

@@ -0,0 +1,12 @@
+from flet_geolocator.geolocator import (
+    Geolocator,
+    GeolocatorActivityType,
+    GeolocatorAndroidSettings,
+    GeolocatorAppleSettings,
+    GeolocatorPermissionStatus,
+    GeolocatorPosition,
+    GeolocatorPositionAccuracy,
+    GeolocatorPositionChangeEvent,
+    GeolocatorSettings,
+    GeolocatorWebSettings,
+)

flet_geolocator-0.1.0/src/flet_geolocator/geolocator.py

@@ -0,0 +1,340 @@
+import json
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Optional
+
+from flet.core.control import Control
+from flet.core.control_event import ControlEvent
+from flet.core.event_handler import EventHandler
+from flet.core.ref import Ref
+from flet.core.types import (
+    ColorValue,
+    DurationValue,
+    OptionalControlEventCallable,
+    OptionalEventCallable,
+    OptionalNumber,
+)
+
+
+class GeolocatorPositionAccuracy(Enum):
+    LOWEST = "lowest"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    BEST = "best"
+    BEST_FOR_NAVIGATION = "bestForNavigation"
+    REDUCED = "reduced"
+
+
+class GeolocatorPermissionStatus(Enum):
+    DENIED = "denied"
+    DENIED_FOREVER = "deniedForever"
+    WHILE_IN_USE = "whileInUse"
+    ALWAYS = "always"
+    UNABLE_TO_DETERMINE = "unableToDetermine"
+
+
+class GeolocatorActivityType(Enum):
+    AUTOMOTIVE_NAVIGATION = "automotiveNavigation"
+    FITNESS = "fitness"
+    OTHER_NAVIGATION = "otherNavigation"
+    AIRBORNE = "airborne"
+    OTHER = "other"
+
+
+@dataclass
+class GeolocatorPosition:
+    latitude: OptionalNumber = None
+    longitude: OptionalNumber = None
+    speed: OptionalNumber = None
+    altitude: OptionalNumber = None
+    timestamp: OptionalNumber = None
+    accuracy: OptionalNumber = None
+    altitude_accuracy: OptionalNumber = None
+    heading: OptionalNumber = None
+    heading_accuracy: OptionalNumber = None
+    speed_accuracy: OptionalNumber = None
+    floor: Optional[int] = None
+    is_mocked: Optional[bool] = None
+
+
+@dataclass
+class GeolocatorSettings:
+    accuracy: Optional[GeolocatorPositionAccuracy] = None
+    distance_filter: Optional[int] = None
+    time_limit: DurationValue = None
+
+
+@dataclass
+class GeolocatorWebSettings(GeolocatorSettings):
+    maximum_age: DurationValue = None
+
+
+@dataclass
+class GeolocatorAppleSettings(GeolocatorSettings):
+    activity_type: Optional[GeolocatorActivityType] = None
+    pause_location_updates_automatically: Optional[bool] = False
+    show_background_location_indicator: Optional[bool] = False
+    allow_background_location_updates: Optional[bool] = True
+
+
+@dataclass
+class GeolocatorAndroidSettings(GeolocatorSettings):
+    force_location_manager: Optional[bool] = False
+    interval_duration: DurationValue = False
+    foreground_notification_text: Optional[str] = None
+    foreground_notification_title: Optional[str] = None
+    foreground_notification_channel_name: Optional[str] = "Background Location"
+    foreground_notification_enable_wake_lock: Optional[bool] = False
+    foreground_notification_enable_wifi_lock: Optional[bool] = False
+    foreground_notification_set_ongoing: Optional[bool] = False
+    foreground_notification_color: Optional[ColorValue] = None
+
+
+class GeolocatorPositionChangeEvent(ControlEvent):
+    def __init__(self, e: ControlEvent):
+        super().__init__(e.target, e.name, e.data, e.control, e.page)
+        d = json.loads(e.data)
+        self.latitude: float = d.get("lat")
+        self.longitude: float = d.get("long")
+
+
+class Geolocator(Control):
+    """
+    A control that allows you to fetch GPS data from your device.
+    This control is non-visual and should be added to `page.overlay` list.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/geolocator
+    """
+
+    def __init__(
+        self,
+        # Control
+        #
+        ref: Optional[Ref] = None,
+        data: Any = None,
+        location_settings: Optional[GeolocatorSettings] = None,
+        on_position_change: OptionalEventCallable[GeolocatorPositionChangeEvent] = None,
+        on_error: OptionalControlEventCallable = None,
+    ):
+        Control.__init__(
+            self,
+            ref=ref,
+            data=data,
+        )
+        self.__on_position_change = EventHandler(
+            lambda e: GeolocatorPositionChangeEvent(e)
+        )
+        self._add_event_handler(
+            "positionChange", self.__on_position_change.get_handler()
+        )
+        self.on_position_change = on_position_change
+        self.on_error = on_error
+        self.location_settings = location_settings
+
+    def _get_control_name(self):
+        return "geolocator"
+
+    def before_update(self):
+        self._set_attr_json("locationSettings", self.location_settings)
+
+    def get_current_position(
+        self,
+        accuracy: Optional[
+            GeolocatorPositionAccuracy
+        ] = GeolocatorPositionAccuracy.BEST,
+        location_settings: Optional[GeolocatorSettings] = None,
+        wait_timeout: Optional[float] = 25,
+    ) -> GeolocatorPosition:
+        ls = (
+            location_settings
+            or self.location_settings
+            or GeolocatorSettings(accuracy=accuracy)
+        )
+        output = self.invoke_method(
+            "get_current_position",
+            {"location_settings": self._convert_attr_json(ls)},
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return (
+            GeolocatorPosition(**json.loads(output))
+            if output is not None
+            else GeolocatorPosition()
+        )
+
+    async def get_current_position_async(
+        self,
+        accuracy: Optional[
+            GeolocatorPositionAccuracy
+        ] = GeolocatorPositionAccuracy.BEST,
+        location_settings: Optional[GeolocatorSettings] = None,
+        wait_timeout: Optional[float] = 25,
+    ) -> GeolocatorPosition:
+        ls = (
+            location_settings
+            or self.location_settings
+            or GeolocatorSettings(accuracy=accuracy)
+        )
+        output = await self.invoke_method_async(
+            "get_current_position",
+            {"location_settings": self._convert_attr_json(ls)},
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return (
+            GeolocatorPosition(**json.loads(output))
+            if output is not None
+            else GeolocatorPosition()
+        )
+
+    def get_last_known_position(
+        self,
+        wait_timeout: Optional[float] = 25,
+    ) -> GeolocatorPosition:
+        assert not self.page.web, "get_last_known_position is not supported on web"
+        output = self.invoke_method(
+            "get_last_known_position",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return (
+            GeolocatorPosition(**json.loads(output))
+            if output is not None
+            else GeolocatorPosition()
+        )
+
+    async def get_last_known_position_async(
+        self,
+        wait_timeout: Optional[float] = 25,
+    ) -> GeolocatorPosition:
+        assert not self.page.web, "get_last_known_position is not supported on web"
+        output = await self.invoke_method_async(
+            "get_last_known_position",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return (
+            GeolocatorPosition(**json.loads(output))
+            if output is not None
+            else GeolocatorPosition()
+        )
+
+    def get_permission_status(
+        self, wait_timeout: Optional[float] = 25
+    ) -> GeolocatorPermissionStatus:
+        p = self.invoke_method(
+            "get_permission_status",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return GeolocatorPermissionStatus(p)
+
+    async def get_permission_status_async(
+        self, wait_timeout: Optional[float] = 25
+    ) -> GeolocatorPermissionStatus:
+        p = await self.invoke_method_async(
+            "get_permission_status",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return GeolocatorPermissionStatus(p)
+
+    def request_permission(
+        self, wait_timeout: Optional[float] = 25
+    ) -> GeolocatorPermissionStatus:
+        p = self.invoke_method(
+            "request_permission",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return GeolocatorPermissionStatus(p)
+
+    async def request_permission_async(
+        self, wait_timeout: Optional[float] = 25
+    ) -> GeolocatorPermissionStatus:
+        p = await self.invoke_method_async(
+            "request_permission",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return GeolocatorPermissionStatus(p)
+
+    def is_location_service_enabled(self, wait_timeout: Optional[float] = 10) -> bool:
+        enabled = self.invoke_method(
+            "is_location_service_enabled",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return enabled == "true"
+
+    async def is_location_service_enabled_async(
+        self, wait_timeout: Optional[float] = 10
+    ) -> bool:
+        enabled = await self.invoke_method_async(
+            "is_location_service_enabled",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return enabled == "true"
+
+    def open_app_settings(self, wait_timeout: Optional[float] = 10) -> bool:
+        assert not self.page.web, "open_app_settings is not supported on web"
+        opened = self.invoke_method(
+            "open_app_settings",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return opened == "true"
+
+    async def open_app_settings_async(self, wait_timeout: Optional[float] = 10) -> bool:
+        assert not self.page.web, "open_app_settings is not supported on web"
+        opened = await self.invoke_method_async(
+            "open_app_settings",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return opened == "true"
+
+    def open_location_settings(self, wait_timeout: Optional[float] = 10) -> bool:
+        assert not self.page.web, "open_location_settings is not supported on web"
+        opened = self.invoke_method(
+            "open_location_settings",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return opened == "true"
+
+    async def open_location_settings_async(
+        self, wait_timeout: Optional[float] = 10
+    ) -> bool:
+        assert not self.page.web, "open_location_settings is not supported on web"
+        opened = await self.invoke_method_async(
+            "open_location_settings",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return opened == "true"
+
+    @property
+    def on_position_change(
+        self,
+    ) -> OptionalEventCallable[GeolocatorPositionChangeEvent]:
+        return self.__on_position_change.handler
+
+    @on_position_change.setter
+    def on_position_change(
+        self, handler: OptionalEventCallable[GeolocatorPositionChangeEvent]
+    ):
+        self.__on_position_change.handler = handler
+        self._set_attr("onPositionChange", True if handler is not None else None)
+
+    @property
+    def on_error(self) -> OptionalControlEventCallable:
+        return self._get_attr("error")
+
+    @on_error.setter
+    def on_error(self, handler: OptionalControlEventCallable):
+        self._add_event_handler("error", handler)