Upload gradio_location_tracker.py

gradio_location_tracker.py

@@ -0,0 +1,496 @@
+import gradio as gr
+import sqlite3
+import json
+import pandas as pd
+from datetime import datetime, timedelta
+import folium
+from folium import plugins
+import requests
+import threading
+import time
+import os
+
+# Configuração do banco de dados
+def init_db():
+    conn = sqlite3.connect('locations.db', check_same_thread=False)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS locations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            device_id TEXT NOT NULL,
+            device_name TEXT NOT NULL,
+            latitude REAL NOT NULL,
+            longitude REAL NOT NULL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+            accuracy REAL,
+            battery_level INTEGER,
+            ip_address TEXT
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+# Função para adicionar localização
+def add_location(device_id, device_name, latitude, longitude, accuracy=0, battery=100):
+    if not all([device_id, device_name, latitude, longitude]):
+        return "❌ Erro: Todos os campos são obrigatórios!"
+    
+    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!"
+        
+        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)}"
+
+# Função para obter mapa atualizado
+def get_updated_map():
+    try:
+        conn = sqlite3.connect('locations.db', check_same_thread=False)
+        
+        # Buscar localizações mais recentes de cada dispositivo
+        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()  # Apenas a localização mais recente de cada dispositivo
+        
+        conn.close()
+        
+        if df_latest.empty:
+            # Mapa padrão centrado no Brasil
+            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_()
+        
+        # Criar mapa centrado na média das localizações
+        center_lat = df_latest['latitude'].mean()
+        center_lng = df_latest['longitude'].mean()
+        m = folium.Map(location=[center_lat, center_lng], zoom_start=12)
+        
+        # Adicionar marcadores para cada dispositivo
+        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():
+            # Determinar status (online se última atualização foi há menos de 5 min)
+            last_update = datetime.strptime(row['timestamp'], '%Y-%m-%d %H:%M:%S')
+            is_online = (datetime.now() - last_update).total_seconds() < 300  # 5 minutos
+            
+            # Escolher cor do marcador
+            color = colors[idx % len(colors)]
+            icon_color = 'green' if is_online else 'red'
+            
+            # Informações do popup
+            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=icon_color, icon='phone', prefix='fa')
+            ).add_to(m)
+            
+            # Adicionar círculo de precisão
+            folium.Circle(
+                [row['latitude'], row['longitude']],
+                radius=row['accuracy'],
+                popup=f"Área de precisão: ±{row['accuracy']:.0f}m",
+                color=color,
+                fill=True,
+                fillOpacity=0.1,
+                weight=1
+            ).add_to(m)
+        
+        # Adicionar histórico de movimento (últimas 24h)
+        for device_id in df_latest['device_id'].unique():
+            device_history = df[df['device_id'] == device_id].sort_values('timestamp')
+            if len(device_history) > 1:
+                coordinates = [[row['latitude'], row['longitude']] for _, row in device_history.iterrows()]
+                folium.PolyLine(
+                    coordinates,
+                    color=colors[list(df_latest['device_id'].unique()).index(device_id) % len(colors)],
+                    weight=2,
+                    opacity=0.8,
+                    popup=f"Trajeto: {device_history.iloc[0]['device_name']}"
+                ).add_to(m)
+        
+        # Adicionar plugin de tela cheia
+        plugins.Fullscreen().add_to(m)
+        
+        # Adicionar mini mapa
+        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>"
+
+# Função para obter estatísticas
+def get_statistics():
+    try:
+        conn = sqlite3.connect('locations.db', check_same_thread=False)
+        
+        # Contar dispositivos únicos
+        cursor = conn.cursor()
+        cursor.execute("SELECT COUNT(DISTINCT device_id) FROM locations")
+        total_devices = cursor.fetchone()[0]
+        
+        # Contar localizações nas últimas 24h
+        cursor.execute("SELECT COUNT(*) FROM locations WHERE timestamp > datetime('now', '-1 day')")
+        locations_24h = cursor.fetchone()[0]
+        
+        # Dispositivos online (última atualização < 5 min)
+        cursor.execute("""
+            SELECT COUNT(DISTINCT device_id) FROM locations 
+            WHERE timestamp > datetime('now', '-5 minutes')
+        """)
+        online_devices = cursor.fetchone()[0]
+        
+        # Última atualização geral
+        cursor.execute("SELECT MAX(timestamp) FROM locations")
+        last_update = cursor.fetchone()[0]
+        
+        conn.close()
+        
+        stats = f"""
+📊 **ESTATÍSTICAS DO SISTEMA**
+
+🔢 **Total de Dispositivos:** {total_devices}
+🟢 **Dispositivos Online:** {online_devices}
+🔴 **Dispositivos Offline:** {total_devices - online_devices}
+
+📍 **Localizações (24h):** {locations_24h}
+⏰ **Última Atualização:** {last_update or 'Nunca'}
+
+---
+*Atualizado automaticamente*
+        """
+        
+        return stats
+        
+    except Exception as e:
+        return f"❌ Erro ao carregar estatísticas: {str(e)}"
+
+# Função para obter lista de dispositivos
+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', '-7 days')
+        '''
+        
+        df = pd.read_sql_query(query, conn)
+        conn.close()
+        
+        if df.empty:
+            return "Nenhum dispositivo encontrado nos últimos 7 dias."
+        
+        # Filtrar apenas a localização mais recente de cada dispositivo
+        df_latest = df[df['rn'] == 1].copy()
+        
+        # Adicionar coluna de status
+        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'
+        )
+        
+        # Formatar coordenadas
+        df_latest['coordenadas'] = df_latest.apply(
+            lambda row: f"{row['latitude']:.6f}, {row['longitude']:.6f}", axis=1
+        )
+        
+        # Selecionar colunas para exibição
+        display_df = df_latest[['device_name', 'device_id', 'status', 'coordenadas', 'timestamp', 'battery_level', 'accuracy']].copy()
+        display_df.columns = ['Nome', 'ID', 'Status', 'Coordenadas', 'Última Atualização', 'Bateria (%)', 'Precisão (m)']
+        
+        return display_df
+        
+    except Exception as e:
+        return f"Erro ao carregar lista de dispositivos: {str(e)}"
+
+# Função para limpeza de dados antigos
+def cleanup_old_data():
+    try:
+        conn = sqlite3.connect('locations.db', check_same_thread=False)
+        cursor = conn.cursor()
+        
+        # Remover dados com mais de 30 dias
+        cursor.execute("DELETE FROM locations WHERE timestamp < datetime('now', '-30 days')")
+        deleted = cursor.rowcount
+        
+        conn.commit()
+        conn.close()
+        
+        return f"✅ Limpeza concluída! {deleted} registros antigos removidos."
+    
+    except Exception as e:
+        return f"❌ Erro na limpeza: {str(e)}"
+
+# Função para exportar dados
+def export_data():
+    try:
+        conn = sqlite3.connect('locations.db', check_same_thread=False)
+        df = pd.read_sql_query("SELECT * FROM locations ORDER BY timestamp DESC", conn)
+        conn.close()
+        
+        if df.empty:
+            return None, "Nenhum dado para exportar."
+        
+        # Salvar como CSV
+        filename = f"localizacoes_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        df.to_csv(filename, index=False, encoding='utf-8')
+        
+        return filename, f"✅ Dados exportados com sucesso! {len(df)} registros salvos em {filename}"
+    
+    except Exception as e:
+        return None, f"❌ Erro na exportação: {str(e)}"
+
+# Interface principal usando Gradio
+def create_interface():
+    init_db()
+    
+    with gr.Blocks(title="📍 Monitor de Localização Familiar", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 📍 Sistema de Monitoramento de Localização Familiar
+        
+        **Monitore a localização de seus familiares com segurança e consentimento.**
+        
+        > ⚠️ **Importante:** Use apenas com consentimento explícito. Respeite a privacidade!
+        """)
+        
+        with gr.Tabs():
+            # Aba 1: Adicionar Localização
+            with gr.TabItem("📱 Enviar Localização"):
+                gr.Markdown("### 📡 Enviar Nova Localização")
+                
+                with gr.Row():
+                    device_id = gr.Textbox(
+                        label="🆔 ID do Dispositivo",
+                        placeholder="Ex: celular_joao",
+                        info="Identificador único do dispositivo"
+                    )
+                    device_name = gr.Textbox(
+                        label="📱 Nome do Dispositivo",
+                        placeholder="Ex: Celular do João",
+                        info="Nome amigável para identificação"
+                    )
+                
+                with gr.Row():
+                    latitude = gr.Textbox(
+                        label="🌐 Latitude",
+                        placeholder="Ex: -23.550520",
+                        info="Coordenada de latitude (GPS)"
+                    )
+                    longitude = gr.Textbox(
+                        label="🌐 Longitude", 
+                        placeholder="Ex: -46.633309",
+                        info="Coordenada de longitude (GPS)"
+                    )
+                
+                with gr.Row():
+                    accuracy = gr.Number(
+                        label="🎯 Precisão (metros)",
+                        value=10,
+                        info="Precisão da localização em metros"
+                    )
+                    battery = gr.Slider(
+                        label="🔋 Nível da Bateria (%)",
+                        minimum=0,
+                        maximum=100,
+                        value=100,
+                        step=1
+                    )
+                
+                send_btn = gr.Button("📡 Enviar Localização", variant="primary", size="lg")
+                send_result = gr.Textbox(label="Resultado", interactive=False)
+                
+                send_btn.click(
+                    add_location,
+                    inputs=[device_id, device_name, latitude, longitude, accuracy, battery],
+                    outputs=send_result
+                )
+                
+                gr.Markdown("""
+                **💡 Dica:** Para obter suas coordenadas atuais:
+                1. Abra o Google Maps no seu celular
+                2. Pressione e segure no seu local atual
+                3. Copie as coordenadas que aparecem
+                """)
+            
+            # Aba 2: Monitoramento
+            with gr.TabItem("🗺️ Mapa em Tempo Real"):
+                gr.Markdown("### 🌍 Visualização em Tempo Real")
+                
+                with gr.Row():
+                    refresh_btn = gr.Button("🔄 Atualizar Mapa", variant="secondary")
+                    auto_refresh = gr.Checkbox(label="🔄 Atualização Automática (30s)", value=True)
+                
+                map_html = gr.HTML(value=get_updated_map(), label="Mapa")
+                
+                refresh_btn.click(
+                    get_updated_map,
+                    outputs=map_html
+                )
+                
+                # Auto-refresh do mapa
+                demo.load(
+                    get_updated_map,
+                    outputs=map_html,
+                    every=30
+                )
+            
+            # Aba 3: Lista de Dispositivos
+            with gr.TabItem("📋 Lista de Dispositivos"):
+                gr.Markdown("### 📱 Dispositivos Monitorados")
+                
+                refresh_devices_btn = gr.Button("🔄 Atualizar Lista", variant="secondary")
+                devices_table = gr.Dataframe(
+                    value=get_device_list(),
+                    label="Dispositivos Ativos",
+                    interactive=False
+                )
+                
+                refresh_devices_btn.click(
+                    get_device_list,
+                    outputs=devices_table
+                )
+                
+                # Auto-refresh da tabela
+                demo.load(
+                    get_device_list,
+                    outputs=devices_table,
+                    every=30
+                )
+            
+            # Aba 4: Estatísticas
+            with gr.TabItem("📊 Estatísticas"):
+                gr.Markdown("### 📈 Estatísticas do Sistema")
+                
+                refresh_stats_btn = gr.Button("🔄 Atualizar Estatísticas", variant="secondary")
+                stats_display = gr.Markdown(value=get_statistics())
+                
+                refresh_stats_btn.click(
+                    get_statistics,
+                    outputs=stats_display
+                )
+                
+                # Auto-refresh das estatísticas
+                demo.load(
+                    get_statistics,
+                    outputs=stats_display,
+                    every=60
+                )
+            
+            # Aba 5: Administração
+            with gr.TabItem("⚙️ Administração"):
+                gr.Markdown("### 🛠️ Ferramentas de Administração")
+                
+                with gr.Row():
+                    cleanup_btn = gr.Button("🧹 Limpar Dados Antigos", variant="secondary")
+                    export_btn = gr.Button("📥 Exportar Dados", variant="secondary")
+                
+                admin_result = gr.Textbox(label="Resultado da Operação", interactive=False)
+                export_file = gr.File(label="Arquivo Exportado", visible=False)
+                
+                cleanup_btn.click(
+                    cleanup_old_data,
+                    outputs=admin_result
+                )
+                
+                def handle_export():
+                    file_path, message = export_data()
+                    return message, file_path
+                
+                export_btn.click(
+                    handle_export,
+                    outputs=[admin_result, export_file]
+                )
+                
+                gr.Markdown("""
+                **⚠️ Informações Importantes:**
+                - Dados são mantidos por 30 dias automaticamente
+                - Use a limpeza manual se necessário
+                - Faça backups regulares dos dados importantes
+                - Este sistema respeita a privacidade - dados ficam no seu servidor
+                """)
+        
+        gr.Markdown("""
+        ---
+        ### 📱 Como Usar no Celular:
+        
+        1. **Para Enviar Localização:** Use a aba "Enviar Localização"
+        2. **Para Monitorar:** Use a aba "Mapa em Tempo Real"  
+        3. **Atualizações:** O sistema atualiza automaticamente
+        
+        ### 🔒 Privacidade e Segurança:
+        - ✅ Dados armazenados localmente no seu servidor
+        - ✅ Sem compartilhamento com terceiros  
+        - ✅ Use apenas com consentimento
+        - ✅ Transparência total sobre quando está ativo
+        
+        **Desenvolvido com ❤️ para famílias que querem se manter conectadas com segurança.**
+        """)
+    
+    return demo
+
+# Executar aplicação
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",  # Permite acesso de outros dispositivos na rede
+        server_port=7860,       # Porta padrão do Gradio
+        share=False,            # True para criar link público temporário
+        debug=True,
+        show_error=True
+    )