Spaces:

cngsm
/

gps

Sleeping

App Files Files Community

cngsm commited on May 24, 2025

Commit

6fb7671

verified ·

1 Parent(s): 5fc83a5

Update app.py

Browse files

Files changed (1) hide show

app.py +129 -251

app.py CHANGED Viewed

@@ -4,10 +4,7 @@ import pandas as pd
 from datetime import datetime
 import folium
 from folium import plugins
-from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse
-import uvicorn
-from threading import Thread
 from geopy.distance import geodesic
 # Configuração do banco de dados
@@ -23,306 +20,187 @@ def init_db():
             longitude REAL NOT NULL,
             timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
             accuracy REAL,
-            battery_level INTEGER,
-            ip_address TEXT
         )
     ''')
     conn.commit()
     conn.close()
 init_db()
-app = FastAPI()
-# Função para verificar movimento significativo
-def is_significant_movement(device_id, new_lat, new_lng):
-    conn = sqlite3.connect('locations.db', check_same_thread=False)
-    cursor = conn.cursor()
-    cursor.execute('''
-        SELECT latitude, longitude FROM locations
-        WHERE device_id = ?
-        ORDER BY timestamp DESC LIMIT 1
-    ''', (device_id,))
-    last_location = cursor.fetchone()
-    conn.close()
-    if not last_location:
-        return True
-    old_lat, old_lng = last_location
-    distance = geodesic((old_lat, old_lng), (new_lat, new_lng)).meters
-    return distance > 50
 # Função para adicionar localização
-def add_location(device_id, device_name, latitude, longitude, accuracy=0, battery=100):
     try:
         lat = float(latitude)
         lng = float(longitude)
-        acc = float(accuracy) if accuracy else 0
-        bat = int(battery) if battery else 100
         if not (-90 <= lat <= 90) or not (-180 <= lng <= 180):
             return "❌ Erro: Coordenadas inválidas!"
-        if not is_significant_movement(device_id, lat, lng):
-            return "✅ Localização recebida (sem movimento significativo)"
         conn = sqlite3.connect('locations.db', check_same_thread=False)
         cursor = conn.cursor()
         cursor.execute('''
             INSERT INTO locations (device_id, device_name, latitude, longitude, accuracy, battery_level)
             VALUES (?, ?, ?, ?, ?, ?)
-        ''', (device_id, device_name, lat, lng, acc, bat))
         conn.commit()
         conn.close()
-        return f"✅ Localização adicionada com sucesso!\n📍 {lat:.6f}, {lng:.6f}\n⏰ {datetime.now().strftime('%H:%M:%S')}"
-    except ValueError:
-        return "❌ Erro: Valores numéricos inválidos!"
     except Exception as e:
         return f"❌ Erro: {str(e)}"
-# Endpoint API
-@app.post("/api/location")
-async def receive_location(request: Request):
-    data = await request.json()
-    result = add_location(
-        data.get('device_id'),
-        data.get('device_name'),
-        data.get('latitude'),
-        data.get('longitude'),
-        data.get('accuracy', 10),
-        data.get('battery', 100)
-    )
-    return {"status": "success" if "✅" in result else "error", "message": result}
 # Função para obter mapa atualizado
 def get_updated_map():
     try:
         conn = sqlite3.connect('locations.db', check_same_thread=False)
-        query = '''
             SELECT device_id, device_name, latitude, longitude,
-                   timestamp, accuracy, battery_level,
-                   ROW_NUMBER() OVER (PARTITION BY device_id ORDER BY timestamp DESC) as rn
-            FROM locations
-            WHERE timestamp > datetime('now', '-1 day')
-        '''
-        df = pd.read_sql_query(query, conn)
-        df_latest = df[df['rn'] == 1].copy()
         conn.close()
-        if df_latest.empty:
             m = folium.Map(location=[-14.235, -51.9253], zoom_start=4)
-            folium.Marker(
-                [-14.235, -51.9253],
-                popup="Nenhum dispositivo encontrado",
-                icon=folium.Icon(color='gray', icon='info-sign')
-            ).add_to(m)
             return m._repr_html_()
-        center_lat = df_latest['latitude'].mean()
-        center_lng = df_latest['longitude'].mean()
-        m = folium.Map(location=[center_lat, center_lng], zoom_start=12)
-        colors = ['red', 'blue', 'green', 'purple', 'orange', 'darkred', 'lightred',
-                 'beige', 'darkblue', 'darkgreen', 'cadetblue', 'darkpurple', 'white',
-                 'pink', 'lightblue', 'lightgreen', 'gray', 'black', 'lightgray']
-        for idx, row in df_latest.iterrows():
-            last_update = datetime.strptime(row['timestamp'], '%Y-%m-%d %H:%M:%S')
-            is_online = (datetime.now() - last_update).total_seconds() < 300
-            popup_html = f"""
-            <div style="font-family: Arial; width: 200px;">
-                <h4>📱 {row['device_name']}</h4>
-                <p><b>ID:</b> {row['device_id']}</p>
-                <p><b>Status:</b> <span style="color: {'green' if is_online else 'red'};">
-                    {'🟢 Online' if is_online else '🔴 Offline'}</span></p>
-                <p><b>Última atualização:</b><br>{row['timestamp']}</p>
-                <p><b>Coordenadas:</b><br>{row['latitude']:.6f}, {row['longitude']:.6f}</p>
-                <p><b>Precisão:</b> ±{row['accuracy']:.0f}m</p>
-                <p><b>Bateria:</b> 🔋 {row['battery_level']}%</p>
-            </div>
-            """
             folium.Marker(
                 [row['latitude'], row['longitude']],
-                popup=folium.Popup(popup_html, min_width=200, max_width=300),
-                tooltip=f"{row['device_name']} - {'Online' if is_online else 'Offline'}",
-                icon=folium.Icon(color='green' if is_online else 'red', icon='phone', prefix='fa')
-            ).add_to(m)
-            folium.Circle(
-                [row['latitude'], row['longitude']],
-                radius=row['accuracy'],
-                popup=f"Área de precisão: ±{row['accuracy']:.0f}m",
-                color=colors[idx % len(colors)],
-                fill=True,
-                fillOpacity=0.1,
-                weight=1
             ).add_to(m)
-        plugins.Fullscreen().add_to(m)
-        minimap = plugins.MiniMap()
-        m.add_child(minimap)
         return m._repr_html_()
     except Exception as e:
-        return f"<div style='color: red; padding: 20px;'>Erro ao carregar mapa: {str(e)}</div>"
 # Interface Gradio
 def create_interface():
-    with gr.Blocks(title="📍 Monitor GPS em Tempo Real", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 📍 Monitoramento GPS em Tempo Real
-        **Visualize a localização de dispositivos com atualização automática**
-        """)
-        with gr.Tabs():
-            with gr.TabItem("🗺️ Mapa em Tempo Real"):
-                map_html = gr.HTML(label="Mapa GPS em Tempo Real")
-                gr.Markdown("""
-                ### Instruções para Celular:
-                1. Acesse: http://[SEU-SERVIDOR]:8000/mobile
-                2. Permita o acesso à localização
-                3. Sua posição será atualizada automaticamente
-                """)
-                gr.Timer(10.0, get_updated_map, [], [map_html])
-            with gr.TabItem("📋 Dispositivos"):
-                devices_table = gr.Dataframe(label="Dispositivos Conectados")
-                gr.Timer(15.0, lambda: get_device_list(), [], [devices_table])
     return demo
-# Página mobile
-mobile_page = """
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Enviar Localização</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <style>
-        body { font-family: Arial, sans-serif; padding: 20px; }
-        button { padding: 10px 15px; font-size: 16px; margin: 10px 0; }
-        #status { margin: 15px 0; font-weight: bold; }
-    </style>
-</head>
-<body>
-    <h1>Compartilhar Localização</h1>
-    <div id="status">Pressione o botão para começar</div>
-    <button id="startBtn">Iniciar Compartilhamento</button>
-    <p id="coordinates"></p>
-    <script>
-        const deviceId = "celular_" + Math.random().toString(36).substring(2, 8);
-        const deviceName = prompt("Digite seu nome:", "Usuário") || "Usuário";
-        let watchId = null;
-        let batteryLevel = 100;
-        // Verificar suporte a bateria
-        if (navigator.getBattery) {
-            navigator.getBattery().then(battery => {
-                batteryLevel = Math.round(battery.level * 100);
-                battery.addEventListener('levelchange', () => {
-                    batteryLevel = Math.round(battery.level * 100);
-                });
-            });
-        }
-        document.getElementById("startBtn").addEventListener("click", async () => {
-            if (watchId) {
-                navigator.geolocation.clearWatch(watchId);
-                watchId = null;
-                document.getElementById("status").textContent = "Compartilhamento parado";
-                document.getElementById("startBtn").textContent = "Iniciar Compartilhamento";
-                return;
-            }
-            document.getElementById("status").textContent = "Obtendo localização...";
-            document.getElementById("startBtn").textContent = "Parar Compartilhamento";
-            watchId = navigator.geolocation.watchPosition(
-                async (position) => {
-                    const { latitude, longitude, accuracy } = position.coords;
-                    document.getElementById("coordinates").innerHTML =
-                        `<strong>Coordenadas:</strong> ${latitude.toFixed(6)}, ${longitude.toFixed(6)}<br>
-                         <strong>Precisão:</strong> ${Math.round(accuracy)} metros<br>
-                         <strong>Bateria:</strong> ${batteryLevel}%`;
-                    try {
-                        const response = await fetch("/api/location", {
-                            method: "POST",
-                            headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({
-                                device_id: deviceId,
-                                device_name: deviceName,
-                                latitude,
-                                longitude,
-                                accuracy,
-                                battery: batteryLevel
-                            })
-                        });
-                        console.log("Localização enviada:", await response.json());
-                    } catch (error) {
-                        console.error("Erro ao enviar localização:", error);
-                    }
-                },
-                (error) => {
-                    document.getElementById("status").textContent = "Erro: " + error.message;
-                },
-                {
-                    enableHighAccuracy: true,
-                    maximumAge: 10000,
-                    timeout: 5000
-                }
-            );
-        });
-    </script>
-</body>
-</html>
-"""
-@app.get("/mobile")
-async def mobile_client():
-    return HTMLResponse(mobile_page)
-def get_device_list():
-    try:
-        conn = sqlite3.connect('locations.db', check_same_thread=False)
-        query = '''
-            SELECT device_id, device_name, latitude, longitude,
-                   timestamp, battery_level, accuracy,
-                   ROW_NUMBER() OVER (PARTITION BY device_id ORDER BY timestamp DESC) as rn
-            FROM locations
-            WHERE timestamp > datetime('now', '-1 day')
-        '''
-        df = pd.read_sql_query(query, conn)
-        conn.close()
-        if df.empty:
-            return pd.DataFrame([{"Mensagem": "Nenhum dispositivo encontrado nas últimas 24 horas"}])
-        df_latest = df[df['rn'] == 1].copy()
-        df_latest['status'] = df_latest['timestamp'].apply(
-            lambda x: '🟢 Online' if (datetime.now() - datetime.strptime(x, '%Y-%m-%d %H:%M:%S')).total_seconds() < 300 else '🔴 Offline'
-        )
-        display_df = df_latest[['device_name', 'device_id', 'status', 'latitude', 'longitude', 'timestamp', 'battery_level', 'accuracy']]
-        display_df.columns = ['Nome', 'ID', 'Status', 'Latitude', 'Longitude', 'Última Atualização', 'Bateria (%)', 'Precisão (m)']
-        return display_df
-    except Exception as e:
-        return pd.DataFrame([{"Erro": f"Erro ao carregar dispositivos: {str(e)}"}])
-def run_gradio():
-    demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
 if __name__ == "__main__":
-    gradio_thread = Thread(target=run_gradio)
-    gradio_thread.start()
-    uvicorn.run(app, host="0.0.0.0", port=8000)

 from datetime import datetime
 import folium
 from folium import plugins
+import webbrowser
 from geopy.distance import geodesic
 # Configuração do banco de dados
             longitude REAL NOT NULL,
             timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
             accuracy REAL,
+            battery_level INTEGER
         )
     ''')
     conn.commit()
     conn.close()
 init_db()
 # Função para adicionar localização
+def add_location(device_id, device_name, latitude, longitude, accuracy=10, battery=100):
     try:
         lat = float(latitude)
         lng = float(longitude)
         if not (-90 <= lat <= 90) or not (-180 <= lng <= 180):
             return "❌ Erro: Coordenadas inválidas!"
         conn = sqlite3.connect('locations.db', check_same_thread=False)
         cursor = conn.cursor()
         cursor.execute('''
             INSERT INTO locations (device_id, device_name, latitude, longitude, accuracy, battery_level)
             VALUES (?, ?, ?, ?, ?, ?)
+        ''', (device_id, device_name, lat, lng, accuracy, battery))
         conn.commit()
         conn.close()
+        return f"✅ Localização atualizada!\n📍 {lat:.6f}, {lng:.6f}\n⏰ {datetime.now().strftime('%H:%M:%S')}"
     except Exception as e:
         return f"❌ Erro: {str(e)}"
+# Função para capturar coordenadas via navegador
+def start_gps_capture(device_id, device_name):
+    # Cria uma página HTML temporária para captura do GPS
+    html_content = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Captura de Localização</title>
+        <script>
+            function captureLocation() {{
+                if (navigator.geolocation) {{
+                    navigator.geolocation.watchPosition(
+                        position => {{
+                            document.getElementById('coords').value =
+                                `${{position.coords.latitude}},${{position.coords.longitude}}`;
+                            document.getElementById('accuracy').value = position.coords.accuracy;
+                            document.getElementById('battery').value =
+                                navigator.getBattery ? (await navigator.getBattery()).level * 100 : 100;
+                            document.forms['locForm'].submit();
+                        }},
+                        error => {{
+                            alert("Erro: " + error.message);
+                        }},
+                        {{ enableHighAccuracy: true }}
+                    );
+                }} else {{
+                    alert("Geolocalização não suportada neste navegador.");
+                }}
+            }}
+        </script>
+    </head>
+    <body onload="captureLocation()">
+        <form id="locForm" action="http://localhost:7860/api/location" method="post">
+            <input type="hidden" name="device_id" value="{device_id}">
+            <input type="hidden" name="device_name" value="{device_name}">
+            <input type="hidden" id="coords" name="coords">
+            <input type="hidden" id="accuracy" name="accuracy" value="10">
+            <input type="hidden" id="battery" name="battery" value="100">
+        </form>
+        <h2>Capturando localização...</h2>
+        <p>Permaneça nesta página para atualizações automáticas.</p>
+    </body>
+    </html>
+    """
+    with open("gps_capture.html", "w") as f:
+        f.write(html_content)
+    webbrowser.open("gps_capture.html")
+    return "✔️ Abrindo captura de GPS no navegador..."
 # Função para obter mapa atualizado
 def get_updated_map():
     try:
         conn = sqlite3.connect('locations.db', check_same_thread=False)
+        df = pd.read_sql_query('''
             SELECT device_id, device_name, latitude, longitude,
+                   timestamp, accuracy, battery_level
+            FROM locations
+            WHERE timestamp = (SELECT MAX(timestamp) FROM locations l2
+                             WHERE l2.device_id = locations.device_id)
+        ''', conn)
         conn.close()
+        if df.empty:
             m = folium.Map(location=[-14.235, -51.9253], zoom_start=4)
+            folium.Marker([-14.235, -51.9253], popup="Nenhum dado disponível").add_to(m)
             return m._repr_html_()
+        m = folium.Map(location=[df.iloc[0]['latitude'], df.iloc[0]['longitude']], zoom_start=15)
+        for _, row in df.iterrows():
             folium.Marker(
                 [row['latitude'], row['longitude']],
+                popup=f"{row['device_name']}<br>Atualizado: {row['timestamp']}",
+                icon=folium.Icon(color='blue')
             ).add_to(m)
         return m._repr_html_()
     except Exception as e:
+        return f"Erro: {str(e)}"
 # Interface Gradio
 def create_interface():
+    with gr.Blocks(title="📍 Monitor GPS Automático") as demo:
+        gr.Markdown("## 📍 Monitor de Localização Familiar")
+        with gr.Row():
+            device_id = gr.Textbox(label="ID do Dispositivo", value="celular_principal")
+            device_name = gr.Textbox(label="Nome para Exibição", value="Celular Principal")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Captura Automática")
+                gps_btn = gr.Button("📡 Iniciar Captura GPS")
+                gps_status = gr.Textbox(interactive=False)
+                gps_btn.click(
+                    start_gps_capture,
+                    inputs=[device_id, device_name],
+                    outputs=gps_status
+                )
+            with gr.Column():
+                gr.Markdown("### Inserção Manual")
+                with gr.Row():
+                    latitude = gr.Number(label="Latitude")
+                    longitude = gr.Number(label="Longitude")
+                manual_btn = gr.Button("📌 Inserir Manualmente")
+                manual_status = gr.Textbox(interactive=False)
+                manual_btn.click(
+                    add_location,
+                    inputs=[device_id, device_name, latitude, longitude],
+                    outputs=manual_status
+                )
+        with gr.Tab("Mapa em Tempo Real"):
+            map_html = gr.HTML(get_updated_map())
+            gr.Timer(10.0, lambda: None, None, map_html, get_updated_map)
+        with gr.Tab("Dados"):
+            gr.Dataframe(
+                lambda: pd.read_sql_query(
+                    "SELECT device_name, latitude, longitude, timestamp FROM locations ORDER BY timestamp DESC",
+                    sqlite3.connect('locations.db')
+                ),
+                interactive=False
+            )
     return demo
+# API simples para receber as coordenadas
+app = gr.Interface(lambda: None, None, None, title="API").app
+@app.post("/api/location")
+async def api_receive_location(request: Request):
+    form = await request.form()
+    coords = form["coords"].split(",")
+    result = add_location(
+        form["device_id"],
+        form["device_name"],
+        coords[0],
+        coords[1],
+        form["accuracy"],
+        form["battery"]
+    )
+    return {"status": "success" if "✅" in result else "error"}
 if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860)