# 📱 Integração Android - Rastreamento GPS

## 🎯 Resumo

A tabela `rastreamento_tempo_real` é alimentada pelo **aplicativo Android** durante as viagens. O app deve enviar coordenadas GPS a cada 30 segundos para a API.

## 🔗 API Endpoint

### URL
```
POST https://sistemas.pinheiroempresas.com.br/controlefrota/backend-php/api-simples-v2.php?acao=atualizar-posicao
```

### Headers
```
Content-Type: application/json
User-Agent: ControleApp-Android/1.0
```

### Dados JSON
```json
{
    "viagem_id": 68,
    "latitude": -11.016369,
    "longitude": -37.076128,
    "velocidade": 25,
    "precisao": 10,
    "altitude": 45
}
```

| Campo | Tipo | Obrigatório | Descrição |
|-------|------|-------------|-----------|
| `viagem_id` | int | ✅ | ID da viagem ativa |
| `latitude` | float | ✅ | Latitude GPS (-90 a 90) |
| `longitude` | float | ✅ | Longitude GPS (-180 a 180) |
| `velocidade` | float | ❌ | Velocidade em km/h |
| `precisao` | float | ❌ | Precisão GPS em metros |
| `altitude` | float | ❌ | Altitude em metros |

### Resposta Sucesso (200)
```json
{
    "sucesso": true,
    "dados": {
        "id": 123,
        "viagem_id": 68,
        "timestamp": "2025-01-25 14:30:00"
    },
    "mensagem": "Posição GPS registrada com sucesso"
}
```

### Resposta Erro (400)
```json
{
    "sucesso": false,
    "dados": null,
    "mensagem": "viagem_id, latitude e longitude são obrigatórios"
}
```

## 📱 Código Android

### 1. Permissões (AndroidManifest.xml)
```xml
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

<service android:name=".LocationService" 
         android:enabled="true" 
         android:exported="false"
         android:foregroundServiceType="location" />
```

### 2. Dependências (build.gradle)
```gradle
dependencies {
    implementation 'com.squareup.okhttp3:okhttp:4.10.0'
    implementation 'org.json:json:20210307'
    implementation 'androidx.work:work-runtime:2.8.1'
}
```

### 3. Service de Localização
```java
public class LocationService extends Service {
    private static final String API_URL = "https://sistemas.pinheiroempresas.com.br/controlefrota/backend-php/api-simples-v2.php?acao=atualizar-posicao";
    private static final int LOCATION_UPDATE_INTERVAL = 30000; // 30 segundos
    
    private LocationManager locationManager;
    private OkHttpClient httpClient;
    private int viagemId;
    
    @Override
    public void onCreate() {
        super.onCreate();
        locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        httpClient = new OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .writeTimeout(10, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .build();
    }
    
    public void iniciarRastreamento(int viagemId) {
        this.viagemId = viagemId;
        
        // Criar notificação para foreground service
        startForeground(1, criarNotificacao());
        
        LocationListener locationListener = new LocationListener() {
            @Override
            public void onLocationChanged(Location location) {
                enviarPosicaoGPS(location);
            }
            
            @Override
            public void onStatusChanged(String provider, int status, Bundle extras) {}
            
            @Override
            public void onProviderEnabled(String provider) {}
            
            @Override
            public void onProviderDisabled(String provider) {}
        };
        
        // Verificar permissões
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) 
            == PackageManager.PERMISSION_GRANTED) {
            
            locationManager.requestLocationUpdates(
                LocationManager.GPS_PROVIDER,
                LOCATION_UPDATE_INTERVAL,
                10, // 10 metros
                locationListener
            );
        }
    }
    
    private void enviarPosicaoGPS(Location location) {
        // Criar JSON
        JSONObject dados = new JSONObject();
        try {
            dados.put("viagem_id", viagemId);
            dados.put("latitude", location.getLatitude());
            dados.put("longitude", location.getLongitude());
            dados.put("velocidade", location.getSpeed() * 3.6f); // m/s para km/h
            dados.put("precisao", location.getAccuracy());
            dados.put("altitude", location.getAltitude());
        } catch (JSONException e) {
            Log.e("GPS", "Erro ao criar JSON", e);
            return;
        }
        
        // Enviar para servidor
        RequestBody body = RequestBody.create(
            dados.toString(), 
            MediaType.parse("application/json")
        );
        
        Request request = new Request.Builder()
            .url(API_URL)
            .post(body)
            .addHeader("Content-Type", "application/json")
            .addHeader("User-Agent", "ControleApp-Android/1.0")
            .build();
        
        // Executar em background
        httpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e("GPS", "Erro ao enviar GPS: " + e.getMessage());
                // Opcional: salvar em banco local para retry
            }
            
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    String responseBody = response.body().string();
                    Log.d("GPS", "GPS enviado: " + responseBody);
                } else {
                    Log.e("GPS", "Erro HTTP: " + response.code());
                }
            }
        });
    }
    
    private Notification criarNotificacao() {
        return new NotificationCompat.Builder(this, "GPS_CHANNEL")
            .setContentTitle("Rastreamento GPS Ativo")
            .setContentText("Enviando localização durante a viagem")
            .setSmallIcon(R.drawable.ic_location)
            .setPriority(NotificationCompat.PRIORITY_LOW)
            .build();
    }
    
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}
```

### 4. Activity Principal
```java
public class MainActivity extends AppCompatActivity {
    private LocationService locationService;
    private int viagemAtiva = 0;
    
    // Iniciar rastreamento quando viagem começar
    public void iniciarViagem(int viagemId) {
        this.viagemAtiva = viagemId;
        
        Intent serviceIntent = new Intent(this, LocationService.class);
        startForegroundService(serviceIntent);
        
        // Opcional: bind para controlar o service
        bindService(serviceIntent, new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                LocationService.LocalBinder binder = (LocationService.LocalBinder) service;
                locationService = binder.getService();
                locationService.iniciarRastreamento(viagemId);
            }
            
            @Override
            public void onServiceDisconnected(ComponentName name) {
                locationService = null;
            }
        }, Context.BIND_AUTO_CREATE);
    }
    
    // Parar rastreamento quando viagem terminar
    public void finalizarViagem() {
        if (locationService != null) {
            locationService.pararRastreamento();
            unbindService(serviceConnection);
        }
        
        Intent serviceIntent = new Intent(this, LocationService.class);
        stopService(serviceIntent);
        
        viagemAtiva = 0;
    }
}
```

## 🔄 Fluxo de Funcionamento

### 1. **Início da Viagem**
```java
// No app quando usuário inicia viagem
iniciarViagem(68); // ID da viagem criada
```

### 2. **Durante a Viagem**
- App coleta GPS a cada 30 segundos
- Envia para API: `POST /api-simples-v2.php?acao=atualizar-posicao`
- Dados salvos na tabela `rastreamento_tempo_real`

### 3. **Fim da Viagem**
```java
// No app quando usuário finaliza viagem
finalizarViagem();
```

### 4. **Visualização Web**
- Usuário acessa `detalhes-viagem.html?id=68`
- Mapa carrega pontos GPS da tabela
- Desenha trajeto completo com linha tracejada azul

## 🧪 Testando

### 1. **Simular App Android**
```bash
# Executar simulação
http://sistemas.pinheiroempresas.com.br/controlefrota/backend-php/test-api-gps.php
```

### 2. **Verificar Dados**
```bash
# Ver pontos GPS inseridos
http://sistemas.pinheiroempresas.com.br/controlefrota/backend-php/test-trajeto-viagem.php?id=68
```

### 3. **Ver no Mapa**
```bash
# Visualizar trajeto
http://sistemas.pinheiroempresas.com.br/controlefrota/backend-php/admin/detalhes-viagem.html?id=68
```

## 📋 Checklist de Implementação

### Backend (✅ Pronto)
- [x] Tabela `rastreamento_tempo_real` criada
- [x] API endpoint `/api-simples-v2.php?acao=atualizar-posicao`
- [x] Mapa web mostrando trajeto
- [x] Testes de simulação

### Android (⚠️ Pendente)
- [ ] Implementar `LocationService`
- [ ] Adicionar permissões de localização
- [ ] Configurar foreground service
- [ ] Integrar com início/fim de viagem
- [ ] Tratar offline/retry
- [ ] Otimizar bateria

## ⚡ Otimizações

### 1. **Bateria**
- Usar LocationManager com intervalo de 30s
- Parar GPS quando app não está em uso
- Usar PRIORITY_BALANCED_POWER_ACCURACY

### 2. **Conectividade**
- Salvar pontos offline em banco local SQLite
- Sincronizar quando conectividade voltar
- Implementar retry automático

### 3. **Precisão**
- Filtrar pontos com precisão > 50m
- Ignorar pontos muito próximos (< 10m)
- Validar velocidade absurda (> 150 km/h)

## 🔧 Troubleshooting

### Problema: GPS não está sendo enviado
1. Verificar permissões de localização
2. Checar conectividade
3. Verificar logs do Android
4. Testar API com `test-api-gps.php`

### Problema: Trajeto não aparece no mapa
1. Verificar se tabela tem dados: `SELECT * FROM rastreamento_tempo_real WHERE viagem_id = X`
2. Verificar console do navegador (F12)
3. Testar API: `test-trajeto-viagem.php?id=X`

---

**Status**: ✅ Backend pronto, ⚠️ Android pendente  
**Próximo passo**: Implementar LocationService no app Android  
**Teste**: http://sistemas.pinheiroempresas.com.br/controlefrota/backend-php/test-api-gps.php 
