flockompass/main.py

from plyer import gps
from kivy.app import App
from kivy.clock import Clock
from kivy.properties import NumericProperty, StringProperty
from kivy.clock import mainthread
from kivy.utils import platform

from kivy.uix.screenmanager import ScreenManager, Screen, RiseInTransition

from kivy_garden.mapview import MapView

from kivy.vector import Vector
from kivy.animation import Animation
from math import floor
import random

#from LatLon23 import LatLon, Latitude, Longitude


class MapScreen(Screen):
    mapview = MapView()
    

class CompassScreen(Screen):
    x_calib = NumericProperty(0)
    y_calib = NumericProperty(0)
    z_calib = NumericProperty(0)

    needle_angle = NumericProperty(0)
    gps_location = StringProperty()
    gps_status = StringProperty('Click Start to get GPS location updates')

    def enable(self):
        self.facade.enable()
        Clock.schedule_interval(self.get_field, 1 / 5.)

    def disable(self):
        self.facade.disable()
        Clock.unschedule(self.get_field)

    def get_field(self, dt):
        needle_angle = 7
        if self.facade.field != (None, None, None):
            self.x_calib, self.y_calib, self.z_calib = self.facade.field
            x, y, z = self.facade.field

            needle_angle = Vector(x, y).angle((0, 1)) + 90.

        # fix animation transition around the unit circle
        if (self.needle_angle % 360) - needle_angle > 180:
            needle_angle += 360
        elif (self.needle_angle % 360) - needle_angle < -180:
            needle_angle -= 360
        # add the number of revolutions to the result
        needle_angle += 360 * floor(self.needle_angle / 360.)

        # animate the needle
        if self._anim:
            self._anim.stop(self)
        self._anim = Animation(needle_angle=needle_angle, d=.2, t='out_quad')
        self._anim.start(self)


    def start(self, minTime, minDistance):
        gps.start(minTime, minDistance)

    def stop(self):
        gps.stop()

    def on_pause(self):
        gps.stop()
        return True

    def on_resume(self):
        gps.start(1000, 0)

    @mainthread
    def on_location(self, **kwargs):
        print('aguas on location')
        # print(kwargs)
        
        # p = LatLon(Latitude(kwargs['lat']),
        #            Longitude(kwargs['lon']))

        # destination_point = LatLon(Latitude(28.89335172),
        #                            Longitude(76.59449171))
        
        self.gps_location = '\n'.join([
            '{}={}'.format(k, v) for k, v in kwargs.items()])
#        self.gps_location += str(p.heading_initial(destination_point))

# bearing = atan2(sin(long2-long1)*cos(lat2), cos(lat1)*sin(lat2)-sin(lat1)*cos(lat2)*cos(long2-long1))
#     bearing = degrees(bearing)
#     bearing = (bearing + 360) % 360
# https://stackoverflow.com/questions/4913349/haversine-formula-in-python-bearing-and-distance-between-two-gps-points#4913653
    @mainthread
    def on_status(self, stype, status):
        print('aguas on status')
        self.gps_status = 'type={}\n{}'.format(stype, status)


        

class FlockompassApp(App):

    lat = 19.3419
    lon = -99.1499

    def move_around(self, t):
        self.lat += random.uniform(-0.01,0.01)
        self.lon += random.uniform(-0.01,0.01)        

        self.ms.ids.mapview.center_on(self.lat, self.lon)

        # where the marker's at
        print(
            self.ms.ids.centermark.lat,
            self.ms.ids.centermark.lon
            )

    
    def request_android_permissions(self):
        from android.permissions import request_permissions, Permission

        def callback(permissions, results):
            if all([res for res in results]):
                print("aguas: callback. All permissions granted.")
            else:
                print("aguas: callback. Some permissions refused.Permission.ACCESS_FINE_LOCATION")

        request_permissions([Permission.ACCESS_COARSE_LOCATION,
                             Permission.ACCESS_FINE_LOCATION],
                            callback)

    def build(self):

        root = ScreenManager(transition=RiseInTransition())
        self.ms = MapScreen(name='map')
        root.add_widget(self.ms)

        
        cs = CompassScreen(name='compass')
        cs._anim = None
        cs.p = None
        
        try:
            gps.configure(on_location=cs.on_location,
                          on_status=cs.on_status)
        except NotImplementedError:
            import traceback
            traceback.print_exc()
            self.gps_status = 'GPS is not implemented for your platform'

        if platform == "android":
            print("gps.py: Android detected. Requesting permissions")
            self.request_android_permissions()

        

        root.add_widget(cs)

        Clock.schedule_interval(self.move_around, 2.0)

        return root


if __name__ == '__main__':
    FlockompassApp().run()




        # Button:
        #     text: 'Use FallOutTransition'
        #     on_release: root.manager.transition = FallOutTransition()

        # Button:
        #     text: 'Use RiseInTransition'
        #     on_release: root.manager.transition = RiseInTransition()