Realtime Database Firebase about react-native-background-geolocation HOT 13 OPEN

BackgroundGeolocation.ready({
      // Geolocation Config
      backgroundPermissionRationale: {
        title: 'Permitir acesso à sua localização em background',
        message:
          'Para obter sua localização com precisão, por favor permita que o App obtenha sua localização o tempo todo.',
        positiveAction: 'Configurar',
        negativeAction: 'Cancelar',
      },
      locationAuthorizationAlert: {
        titleWhenOff: 'Localização indisponível',
        titleWhenNotEnabled: 'Localização em background indisponível',
        instructions:
          'Para obter sua localização com precisão, por favor permita que o App obtenha sua localização o tempo todo.',
        settingsButton: 'Configurar',
        cancelButton: 'Cancelar',
      },
      notification: {
        title: 'Acompanhando sua localização',
        text: 'Acompanhamos sua localização para enviar corridas próximas e monitorar a entrega.',
      },
      desiredAccuracy: BackgroundGeolocation.DESIRED_ACCURACY_HIGH,
      distanceFilter: 10,
      // Activity Recognition
      stopTimeout: 5,
      // Application config
      debug: true, // <-- enable this hear sounds for background-geolocation life-cycle.
      logLevel: BackgroundGeolocation.LOG_LEVEL_VERBOSE,
      stopOnTerminate: false,   // <-- Allow the background-service to continue tracking when user closes the app.
      startOnBoot: true,        // <-- Auto start tracking when device is powered-up.
      // HTTP / SQLite config
      url: 'https://shark-app-j3vbs.ondigitalocean.app/geolocationbackground',
      batchSync: false,       // <-- [Default: false] Set true to sync locations to server in a single HTTP request.
      autoSync: true,         // <-- [Default: true] Set true to sync each location to server as it arrives.
      headers: {              // <-- Optional HTTP headers
        // "X-FOO": "bar"
        "Authorization": `Bearer ${prestador.token}`
      },
      params: {               // <-- Optional HTTP params
        // "auth_token": "maybe_your_server_authenticates_via_token_YES?"
        "prestador_id": prestador.id,
        "nome": prestador.nome,
        "genero": prestador.genero,
        "foto_perfil": prestador.foto_perfil,
        "prestadorsubcategoria": prestador.prestadorsubcategoria
      }
    }).then((state) => {
      setEnabled(state.enabled)
      console.log("- BackgroundGeolocation is configured and ready: ", state.enabled);
    });

if (error.message === "Waiting for previous start action to complete") {
          BackgroundGeolocation.stop().then(() => {
            console.log("BackgroundGeolocation stopped, restarting...");
            BackgroundGeolocation.start().then(() => {
              console.log("BackgroundGeolocation restarted");
            }).catch(error => {
              console.error("Error restarting BackgroundGeolocation: ", error);
            });
          }).catch(stopError => {
            console.error("Error stopping BackgroundGeolocation: ", stopError);
          });
        } else {
          console.error("Error starting BackgroundGeolocation: ", error);
        }

import React, { useContext } from 'react';
import { Switch, Text, View, PermissionsAndroid } from 'react-native';
import BackgroundGeolocation from "react-native-background-geolocation";
import { AuthContext } from '../../contexts/AuthContext';
import api from '../../services/api';

const HelloWorld = () => {
  const [enabled, setEnabled] = React.useState(false);
  const [location, setLocation] = React.useState('');

  const { prestador } = useContext(AuthContext);

  React.useEffect(() => {
    const requestLocationPermissions = async () => {
      try {
        const granted = await PermissionsAndroid.requestMultiple([
          PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
          PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
          PermissionsAndroid.PERMISSIONS.ACCESS_BACKGROUND_LOCATION,
        ]);

        if (
          granted['android.permission.ACCESS_FINE_LOCATION'] === PermissionsAndroid.RESULTS.GRANTED &&
          granted['android.permission.ACCESS_COARSE_LOCATION'] === PermissionsAndroid.RESULTS.GRANTED &&
          granted['android.permission.ACCESS_BACKGROUND_LOCATION'] === PermissionsAndroid.RESULTS.GRANTED
        ) {
          console.log('Você tem todas as permissões de localização');
        } else {
          console.log('Permissões de localização negadas');
        }
      } catch (err) {
        console.warn(err);
      }
    };

    requestLocationPermissions();

    const onLocation = BackgroundGeolocation.onLocation(async (location) => {
      console.log('[onLocation]', location);
      setLocation(JSON.stringify(location, null, 2));

      let dados = {
        "prestador_id": prestador.id,
        "nome": prestador.nome,
        "genero": prestador.genero,
        "foto_perfil": prestador.foto_perfil,
        "prestadorsubcategoria": prestador.prestadorsubcategoria,
        "location": {
          "coords": {
            "latitude": location.coords.latitude,
            "longitude": location.coords.longitude,
          }
        }
      };
      
      try {
        const response = await api.post('/geolocationbackground/', dados, {
          headers: {
            'Authorization': `Bearer ${prestador.token}`
          }
        });
        console.log('Post successful: ', response.data);
      } catch (error) {
        console.error('Post failed: ', error);
      }
    });

    const onMotionChange = BackgroundGeolocation.onMotionChange((event) => {
      console.log('[onMotionChange]', event);
    });

    const onActivityChange = BackgroundGeolocation.onActivityChange((event) => {
      console.log('[onActivityChange]', event);
    });

    const onProviderChange = BackgroundGeolocation.onProviderChange((event) => {
      console.log('[onProviderChange]', event);
    });

    BackgroundGeolocation.ready({
      backgroundPermissionRationale: {
        title: 'Permitir acesso à sua localização em background',
        message: 'Para obter sua localização com precisão, por favor permita que o App obtenha sua localização o tempo todo.',
        positiveAction: 'Configurar',
        negativeAction: 'Cancelar',
      },
      locationAuthorizationAlert: {
        titleWhenOff: 'Localização indisponível',
        titleWhenNotEnabled: 'Localização em background indisponível',
        instructions: 'Para obter sua localização com precisão, por favor permita que o App obtenha sua localização o tempo todo.',
        settingsButton: 'Configurar',
        cancelButton: 'Cancelar',
      },
      notification: {
        title: 'Acompanhando sua localização',
        text: 'Acompanhamos sua localização para enviar corridas próximas e monitorar a entrega.',
      },
      desiredAccuracy: BackgroundGeolocation.DESIRED_ACCURACY_HIGH,
      distanceFilter: 10,
      stopTimeout: 5,
      debug: true,
      logLevel: BackgroundGeolocation.LOG_LEVEL_VERBOSE,
      stopOnTerminate: false,
      startOnBoot: true,
      url: 'https://shark-app-j3vbs.ondigitalocean.app/geolocationbackground',
      batchSync: false,
      autoSync: true,
      headers: {
        "Authorization": `Bearer ${prestador.token}`
      },
      params: {
        "prestador_id": prestador.id,
        "nome": prestador.nome,
        "genero": prestador.genero,
        "foto_perfil": prestador.foto_perfil,
        "prestadorsubcategoria": prestador.prestadorsubcategoria
      }
    }).then((state) => {
      setEnabled(state.enabled);
      console.log("- BackgroundGeolocation is configured and ready: ", state.enabled);

      let Logger = BackgroundGeolocation.logger;
      Logger.emailLog('[email protected]')
        .then(success => {
          console.log(success, '[emailLog] success');
        })
        .catch(error => {
          console.log('[emailLog] FAILURE: ', error);
        });
    });

    return () => {
      onLocation.remove();
      onMotionChange.remove();
      onActivityChange.remove();
      onProviderChange.remove();
    };
  }, []);

  React.useEffect(() => {
    if (enabled) {
      BackgroundGeolocation.start();
    } else {
      BackgroundGeolocation.stop();
      setLocation('');
    }
  }, [enabled]);

  return (
    <View style={{ alignItems: 'center' }}>
      <Text>Click to enable BackgroundGeolocation</Text>
      <Switch value={enabled} onValueChange={setEnabled} />
      <Text style={{ fontFamily: 'monospace', fontSize: 12 }}>{location}</Text>
    </View>
  );
};

export default HelloWorld;

notification: {
                priority: BackgroundGeolocation.NOTIFICATION_PRIORITY_MIN,
                title: 'Acompanhando sua localização',
                text: 'Acompanhamos sua localização para enviar chamados de clientes próximos a você.',
            },