# data[].attributes.body
A faire en autonomie selon le cahier des charges.

La correction sera postée plus tard.

# data[].attributes.body
Utiliser le canal de groupe Teams pour communiquer

Chaque stagiaire indique par un pouce lorsqu'il a réussi son test d'intégration et indique OBLIGATOIREMENT un commentaire (même trivial) ou avec des astuces, liens, tutos, etc.

Chaque validation de TU doit être justifiée ! (un code, une capture d'écran, etc.).

# data[].attributes.body
1. Objectifs du projet :

Développer une application capable de détecter automatiquement la présence de publicités sur un décodeur TV à l'aide d'une caméra IP.

Intégrer un modèle d'intelligence artificielle pour effectuer la classification des images en deux classes : "PUB" et "NoPub".

Utiliser un feu tricolore (simulant le décodeur TV) pour indiquer visuellement si une publicité est détectée.

2. Objectifs fonctionnels :

Détection automatique des publicités :

La caméra IP capture en continu des images du flux télévisuel.

Le modèle d'intelligence artificielle analyse ces images et classe chaque séquence comme "PUB" ou "NoPub" en temps réel.

Gestion des logs et des hyperparamètres :

Les salves d'images détectées sont stockées dans une base de données NoSQL Firebase.

Chaque salve est accompagnée d'un fichier log contenant des informations telles que la durée de la salve, le nombre d'images, les hyperparamètres du modèle, l'horodatage, ainsi que les résultats de prédiction pour chaque image et la prédiction moyenne par classe.

Interface Web dynamique avec React :

Le site web offre une vue en direct de la caméra IP, permettant à l'administrateur de surveiller le flux télévisuel.

Possibilité de consulter n'importe quelle salve d'images en fonction de la date et de l'heure.

Accès aux rapports détaillés pour chaque salve sélectionnée.

Capacité d'insérer de nouveaux échantillons pour les classes du modèle ("PUB" et "NoPub").

Pouvoir vérifier le système de notification à l'administrateur via un bouton test qui envoie un message trial par mail.

Communication avec le feu tricolore (simulateur décodeur) :

Des requêtes HTTP sont utilisées pour changer la couleur du feu tricolore selon les résultats de prédiction du modèle.

Vert : Probabilité de "NoPub" > 70%

Orange : Probabilité entre 5% et 70% sur la classe majoritaire

Rouge : Probabilité de "PUB" > 70%

Administration et notifications :

Connexion sécurisée pour l'administrateur sur le site web.

Alerte par mail ou notifications Push en cas de défaillance système (connexion BDD, API décodeur, caméra IP, modèle, etc.).

3. Livrables :

Code source du projet (modèle d'IA, script principal, site web) avec le lien public du site web.

Code source du script Python.

Extraction du modèle de la base de données Firebase.

Dépôt GitHub du projet avec un fichier ReadMe indiquant la procédure pour faire fonctionner le projet (librairies Python à installer, etc.).

# data[].attributes.headline
Découpage du projet en briefs projets Simplonline

# data[].attributes.subject
Découpage du projet en briefs projets Simplonline

# data[].attributes.body
Un dépot sur Simpolonline avec le lien vers votre GitHub dans l'organisation devIA2025.

Deadline :

Les compétences du référentiel seront évaluées.

# data[].attributes.body
Améliorations optionnelles :

Déploiement sur Azure :

Possibilité de déployer le modèle et le script Python sur Azure et d'y accéder via l'API d'Azure.

Réentrainement du modèle :

Fonctionnalité sur le site web permettant de réentrainer le modèle en fonction des hyperparamètres renseignés.

Application client pro :

Création d'une application dédiée pour les clients choisis afin de fournir des retours sur les erreurs du modèle.ts à éclaircir

# data[].attributes.body
Organisez votre GitHub OBLIGATOIREMENT comme suit :

organisation_DevIA2025/{nom_du_stagiaire}/Projets/Pub_NoPub/TU_TI/{nom_du_test}/{fichiers_preuve_du_test}

Vous devrez obligatoirement et pour chaque test unitaire fournir un justificatif (code python, fichier texte avec une rédaction, capture d'écran, image, etc.) comme mentionné dans la description de chaque test.

# data[].attributes.attachment_link.readable_text
We just wrapped up our virtual Firebase Summit 2020, which included a keynote, technical sessions, and hands on learning materials. If you missed the online event - or if you simply want a refresher - here's a recap of everything we announced plus highlights of our recent launches.

# data[].attributes.attachment_link.description
We just wrapped up our virtual Firebase Summit 2020, which included a keynote, technical sessions, and hands on learning materials. If you missed the online event - or if you simply want a refresher - here's a recap of everything we announced plus highlights of our recent launches.

# data[].attributes.body
Effectuer un "npm install" dans le répertoire principal

puis "npm run start".

Bien sur, il faut avoir node.js installé (https://nodejs.org/en/download) et npm.

Le lancement de "npm run start" devrait lancer un serveur web sur votre machine et afficher le site web sur votre navigateur.

Il s'agit d'une boite à outils permettant de voir tout ce que le package propose en terme d'interface. A vous de comprendre comment faire la votre ;)

# data[].attributes.attachment_link.title
Jeremy Ranguis / Template_REACT_Firebase · GitLab

# data[].attributes.headline
Déployer une application REACT sur firebase

# data[].attributes.subject
Déployer une application REACT sur firebase

# data[].attributes.body
https://medium.com/swlh/how-to-deploy-a-react-app-with-firebase-hosting-98063c5bf425

# data[].attributes.attachment_link.readable_text
In this tutorial, I will be demonstrating how you can deploy your React app using Firebase Hosting. I will assume that you already have a Firebase project set up. If you do not, you can create one using the Firebase Console.
npx create-react-app firebase-hosting-demo
You will also need to ensure have a React app created. For this, I will use Create React App. You can create a new React app by running the following:
npm install firebase-tools -g
Next, you will need to install the firebase tools that will allow you to deploy your app. You can install the tools by running the following:
firebase login
You will now need to login to Firebase in your terminal. You will be prompted to enter your email and password if you're not already logged in. Also, make sure that you are inside of the root directory of your React app. For me, it's ~/firebase-hosting-demo. Run the following:
firebase init
Now that you're logged in, you will need to initialize Firebase in your React app. Run the following:

You will then be prompted with a series of questions and configuration options that I will walk through with you.

Select Hosting: Configure and deploy Firebase Hosting sites.

Select Use an existing project

# data[].attributes.attachment_link.title
How to Deploy a React App with Firebase Hosting

# data[].attributes.attachment_link.description
In this tutorial, I will be demonstrating how you can deploy your React app using Firebase Hosting. I will assume that you already have a Firebase project set up. If you do not, you can create one...

# data[].attributes.headline
Se connecter à la BDD Firestore de Firebase en python

# data[].attributes.subject
Se connecter à la BDD Firestore de Firebase en python

# data[].attributes.attachment_link.readable_text
Ce démarrage rapide vous montre comment configurer Cloud Firestore, ajouter des données, puis afficher les données que vous venez d'ajouter dans la console Firebase.

Créer une base de données Cloud Firestore

1. Si vous ne l'avez pas déjà fait, créez un projet Firebase : dans la console Firebase , cliquez sur Ajouter un projet , puis suivez les instructions à l'écran pour créer un projet Firebase ou pour ajouter des services Firebase à un projet GCP existant.

2. Accédez à la section Cloud Firestore de la console Firebase . Vous serez invité à sélectionner un projet Firebase existant. Suivez le workflow de création de base de données.

3. Sélectionnez un mode de démarrage pour vos règles de sécurité Cloud Firestore :

Mode d'essai

Idéal pour démarrer avec les bibliothèques clientes mobiles et Web, mais permet à quiconque de lire et d'écraser vos données. Après le test, assurez-vous de consulter la section Sécurisez vos données .

Pour démarrer avec le Web, les plateformes Apple ou le SDK Android, sélectionnez le mode test.

Mode verrouillé

Refuse toutes les lectures et écritures des clients mobiles et Web. Vos serveurs d'applications authentifiés (C#, Go, Java, Node.js, PHP, Python ou Ruby) peuvent toujours accéder à votre base de données.

Pour démarrer avec la bibliothèque cliente du serveur C#, Go, Java, Node.js, PHP, Python ou Ruby, sélectionnez le mode verrouillé.

Votre ensemble initial de règles de sécurité Cloud Firestore s'appliquera à votre base de données Cloud Firestore par défaut. Si vous créez plusieurs bases de données pour votre projet, vous pouvez déployer des règles de sécurité Cloud Firestore pour chaque base de données.

4. Sélectionnez un emplacement pour votre base de données.

Ce paramètre d'emplacement correspond à l'emplacement des ressources Google Cloud Platform (GCP) par défaut de votre projet. Notez que cet emplacement sera utilisé pour les services GCP de votre projet qui nécessitent un paramètre d'emplacement, en particulier votre bucket Cloud Storage par défaut et votre application App Engine (qui est obligatoire si vous utilisez Cloud Scheduler).

Si vous ne parvenez pas à sélectionner un emplacement, cela signifie que votre projet dispose déjà d'un emplacement de ressources GCP par défaut. Il a été défini soit lors de la création du projet, soit lors de la configuration d'un autre service nécessitant un paramètre d'emplacement.

Avertissement : Après avoir défini l'emplacement des ressources GCP par défaut de votre projet, vous ne pouvez pas le modifier.

Cloud Firestore et App Engine : vous ne pouvez pas utiliser à la fois Cloud Firestore et Cloud Datastore dans le même projet, ce qui peut affecter les applications utilisant App Engine. Essayez d'utiliser Cloud Firestore avec un autre projet.
Lorsque vous activez Cloud Firestore, cela active également l'API dans Cloud API Manager .

Configurez votre environnement de développement

Ajoutez les dépendances requises et les bibliothèques clientes à votre application.

1. Suivez les instructions pour ajouter Firebase à votre application Web .

2. Ajoutez les bibliothèques Firebase et Cloud Firestore à votre application :

<script src="https://www.gstatic.com/firebasejs/10.5.0/firebase-app-compat.js"></script>
<script src="https://www.gstatic.com/firebasejs/10.5.0/firebase-firestore-compat.js"></script>
Le SDK Cloud Firestore est également disponible sous forme de package npm.

npm install firebase@10.5.0 --save

Vous devrez exiger manuellement Firebase et Cloud Firestore.

import firebase from "firebase/compat/app";
// Required for side-effects
import "firebase/firestore";

Vous recherchez une bibliothèque Firestore compacte et n'avez besoin que de simples fonctionnalités REST/CRUD ? Essayez le

1. Suivez les instructions pour ajouter Firebase à votre application Web .

2. Le SDK Cloud Firestore est disponible sous forme de package npm.

npm install firebase@10.5.0 --save

Vous devrez importer à la fois Firebase et Cloud Firestore.

import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";

SDK Firestore Lite , disponible uniquement via npm.

Consultez notre guide d'installation pour découvrir les différentes manières d'ajouter des SDK Firebase à votre projet Apple, notamment en important directement des frameworks et en utilisant CocoaPods.

1. Dans Xcode, avec votre projet d'application ouvert, accédez à File > Swift Packages > Add Package Dependency .

2. Lorsque vous y êtes invité, ajoutez le référentiel SDK des plates-formes Apple Firebase :

  https://github.com/firebase/firebase-ios-sdk

Remarque : Les nouveaux projets doivent utiliser la version par défaut (la dernière) du SDK, mais vous pouvez choisir une version plus ancienne si nécessaire.
3. Choisissez la bibliothèque Firestore.

4. Une fois terminé, Xcode commencera automatiquement à résoudre et à télécharger vos dépendances en arrière-plan.

1. Suivez les instructions pour ajouter Firebase à votre application Android .

2. À l'aide du Firebase Android BoM , déclarez la dépendance de la bibliothèque Cloud Firestore Android dans le fichier Gradle de votre module (au niveau de l'application) (généralement app/build.gradle.kts ou app/build.gradle ).

dependencies {
// Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:32.3.1"))// Declare the dependency for the Cloud Firestore library // When using the BoM, you don't specify versions in Firebase library dependenciesimplementation("com.google.firebase:firebase-firestore-ktx") }

En utilisant Firebase Android BoM , votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

(Alternative) Déclarez les dépendances de la bibliothèque Firebase sans utiliser la BoM

Si vous choisissez de ne pas utiliser la BoM Firebase, vous devez spécifier chaque version de la bibliothèque Firebase dans sa ligne de dépendance.

Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, nous vous recommandons fortement d'utiliser la BoM pour gérer les versions de bibliothèque, ce qui garantit que toutes les versions sont compatibles.

dependencies {
// Declare the dependency for the Cloud Firestore library // When NOT using the BoM, you must specify versions in Firebase library dependenciesimplementation("com.google.firebase:firebase-firestore-ktx:24.8.1") }

1. Suivez les instructions pour ajouter Firebase à votre application Android .

2. À l'aide du Firebase Android BoM , déclarez la dépendance de la bibliothèque Cloud Firestore Android dans le fichier Gradle de votre module (au niveau de l'application) (généralement app/build.gradle.kts ou app/build.gradle ).

dependencies {
// Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:32.3.1"))// Declare the dependency for the Cloud Firestore library // When using the BoM, you don't specify versions in Firebase library dependenciesimplementation("com.google.firebase:firebase-firestore") }

En utilisant Firebase Android BoM , votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

(Alternative) Déclarez les dépendances de la bibliothèque Firebase sans utiliser la BoM

Si vous choisissez de ne pas utiliser la BoM Firebase, vous devez spécifier chaque version de la bibliothèque Firebase dans sa ligne de dépendance.

Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, nous vous recommandons fortement d'utiliser la BoM pour gérer les versions de bibliothèque, ce qui garantit que toutes les versions sont compatibles.

dependencies {
// Declare the dependency for the Cloud Firestore library // When NOT using the BoM, you must specify versions in Firebase library dependenciesimplementation("com.google.firebase:firebase-firestore:24.8.1") }

1. Ajout d'une ligne de code à la configuration de test de votre application pour vous connecter à l'émulateur.

2. À partir de la racine du répertoire de votre projet local, exécutez firebase emulators:start .

3. Passer des appels à partir du code prototype de votre application à l'aide d'un SDK de plateforme Cloud Firestore, comme d'habitude.

1. Si vous ne l'avez pas déjà fait, configurez et initialisez Firebase dans votre application Flutter.

2. Depuis la racine de votre projet Flutter, exécutez la commande suivante pour installer le plugin :
flutter pub add cloud_firestore

3. Une fois terminé, reconstruisez votre application Flutter :
flutter run

4. Facultatif : améliorez les temps de construction iOS et macOS en incluant le framework précompilé.
Actuellement, le SDK Firestore pour iOS dépend d'un code dont la création dans Xcode peut prendre jusqu'à 5 minutes. Pour réduire considérablement les temps de construction, vous pouvez utiliser une version pré-compilée en ajoutant cette ligne au bloc target 'Runner' do dans votre Podfile :

target 'Runner' do
  pod 'FirebaseFirestore', :git => 'https://github.com/invertase/firestore-ios-sdk-frameworks.git', :tag => '8.15.0'
  # ...
end

De plus, assurez-vous d'avoir mis à niveau CocoaPods vers la version 1.9.1 ou supérieure :

gem install cocoapods

Pour plus d'informations, consultez le problème sur GitHub .

1. Ajoutez le SDK d'administration Firebase à votre application :

2. Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les informations d'identification appropriées dans votre environnement.

1. Ajoutez le SDK Firebase Admin à votre application Python :

pip install --upgrade firebase-admin

2. Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les informations d'identification appropriées dans votre environnement.

import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore"; // TODO: Replace the following with your app's Firebase project configuration // See: https://support.google.com/firebase/answer/7015592 const firebaseConfig = {FIREBASE_CONFIGURATION }; // Initialize Firebase const app = initializeApp(firebaseConfig); // Initialize Cloud Firestore and get a reference to the service const db = getFirestore(app);

import firebase from "firebase/app";
import "firebase/firestore"; // TODO: Replace the following with your app's Firebase project configuration // See: https://support.google.com/firebase/answer/7015592 const firebaseConfig = {FIREBASE_CONFIGURATION }; // Initialize Firebase firebase.initializeApp(firebaseConfig); // Initialize Cloud Firestore and get a reference to the service const db = firebase.firestore();

import FirebaseCore
import FirebaseFirestore

FirebaseApp.configure()

let db = Firestore.firestore()

@import FirebaseCore;
@import FirebaseFirestore;

// Use Firebase library to configure APIs
[FIRApp configure];

FIRFirestore *defaultFirestore = [FIRFirestore firestore];

// Access a Cloud Firestore instance from your Activity

val db = Firebase.firestore

// Access a Cloud Firestore instance from your Activity

FirebaseFirestore db = FirebaseFirestore.getInstance();

db = FirebaseFirestore.instance;

Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour une référence complète, consultez Initialiser le SDK Admin .
Initialiser sur Google Cloud

import com.google.auth.oauth2.GoogleCredentials;
import com.google.cloud.firestore.Firestore;

import com.google.firebase.FirebaseApp;
import com.google.firebase.FirebaseOptions;

// Use the application default credentials
GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredentials(credentials)
    .setProjectId(projectId)
    .build();
FirebaseApp.initializeApp(options);

Firestore db = FirestoreClient.getFirestore();

Initialisez sur votre propre serveur

import com.google.auth.oauth2.GoogleCredentials;
import com.google.cloud.firestore.Firestore;

import com.google.firebase.FirebaseApp;
import com.google.firebase.FirebaseOptions;

// Use a service account
InputStream serviceAccount = new FileInputStream("path/to/serviceAccount.json"); GoogleCredentials credentials = GoogleCredentials.fromStream(serviceAccount); FirebaseOptions options = new FirebaseOptions.Builder() .setCredentials(credentials) .build(); FirebaseApp.initializeApp(options); Firestore db = FirestoreClient.getFirestore();

Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour une référence complète, consultez Initialiser le SDK Admin .
Initialiser sur Google Cloud
import firebase_admin
from firebase_admin import firestore

# Application Default credentials are automatically created.
app = firebase_admin.initialize_app()
db = firestore.client()

import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore

# Use the application default credentials.
cred = credentials.ApplicationDefault()

firebase_admin.initialize_app(cred)
db = firestore.client()

Initialisez sur votre propre serveur
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore

# Use a service account.
cred = credentials.Certificate('path/to/serviceAccount.json')

app = firebase_admin.initialize_app(cred)

db = firestore.client()

Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour une référence complète, consultez Initialiser le SDK Admin .
Initialiser sur Google Cloud
import firebase_admin
from firebase_admin import firestore_async

# Application Default credentials are automatically created.
app = firebase_admin.initialize_app()
db = firestore_async.client()

import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore_async

# Use the application default credentials.
cred = credentials.ApplicationDefault()

firebase_admin.initialize_app(cred)
db = firestore_async.client()

Initialisez sur votre propre serveur
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore_async

# Use a service account.
cred = credentials.Certificate('path/to/serviceAccount.json')

app = firebase_admin.initialize_app(cred)

db = firestore_async.client()

// Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
App::Create();
Firestore* db = Firestore::GetInstance();

Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour une référence complète, consultez Initialiser le SDK Admin .

Initialiser sur Cloud Functions
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');

initializeApp();

const db = getFirestore();

Initialiser sur Google Cloud
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');

initializeApp({
  credential: applicationDefault()
});

const db = getFirestore();

Initialisez sur votre propre serveur
Pour utiliser le SDK Firebase Admin sur votre propre serveur (ou tout autre environnement Node.js), utilisez un compte de service . Accédez à IAM et administrateur > Comptes de service dans la console Google Cloud. Générez une nouvelle clé privée et enregistrez le fichier JSON. Utilisez ensuite le fichier pour initialiser le SDK :

const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');

const serviceAccount = require('./path/to/serviceAccountKey.json');

initializeApp({
  credential: cert(serviceAccount)
});

const db = getFirestore();

Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour une référence complète, consultez Initialiser le SDK Admin .
Initialiser sur Google Cloud

import (
  "log"

  firebase "firebase.google.com/go"
  "google.golang.org/api/option"
)

// Use the application default credentials
ctx := context.Background()
conf := &firebase.Config{ProjectID: projectID}
app, err := firebase.NewApp(ctx, conf)
if err != nil {
  log.Fatalln(err)
}

client, err := app.Firestore(ctx)
if err != nil {
  log.Fatalln(err)
}
defer client.Close()

Initialisez sur votre propre serveur

import (
  "log"

  firebase "firebase.google.com/go"
  "google.golang.org/api/option"
)

// Use a service account
ctx := context.Background()
sa := option.WithCredentialsFile("path/to/serviceAccount.json")
app, err := firebase.NewApp(ctx, nil, sa)
if err != nil {
  log.Fatalln(err)
}

client, err := app.Firestore(ctx)
if err != nil {
  log.Fatalln(err)
}
defer client.Close()

using Firebase.Firestore;
using Firebase.Extensions;

FirebaseFirestore db = FirebaseFirestore.DefaultInstance;

// Allow read/write access on all documents to any user signed in to the application service cloud.firestore { match /databases/{database}/documents { match /{document=**} { allow read, write: if request.auth != null; } } }

// Deny read/write access to all users under any conditions service cloud.firestore { match /databases/{database}/documents { match /{document=**} { allow read, write: if false; } } }

// Allow read/write access to all users under any conditions // Warning: **NEVER** use this rule set in production; it allows // anyone to overwrite your entire database. service cloud.firestore { match /databases/{database}/documents { match /{document=**} { allow read, write: if true; } } }

1. Suivez les instructions pour ajouter Firebase à votre projet C++ .

2. Interface C++ pour Android.

Dépendances graduées. Ajoutez ce qui suit au fichier Gradle de votre module (au niveau de l'application) (généralement app/build.gradle ):

        android.defaultConfig.externalNativeBuild.cmake {
          arguments "-DFIREBASE_CPP_SDK_DIR=$gradle.firebase_cpp_sdk_dir"
        }

        apply from: "$gradle.firebase_cpp_sdk_dir/Android/firebase_dependencies.gradle"
        firebaseCpp.dependencies {
          // earlier entries
          auth
          firestore
        }

Dépendances binaires. De même, la méthode recommandée pour obtenir les dépendances binaires consiste à ajouter ce qui suit à votre fichier CMakeLists.txt :

        add_subdirectory(${FIREBASE_CPP_SDK_DIR} bin/ EXCLUDE_FROM_ALL)
        set(firebase_libs firebase_auth firebase_firestore firebase_app)
        # Replace the target name below with the actual name of your target,
        # for example, "native-lib".
        target_link_libraries(${YOUR_TARGET_NAME_HERE} "${firebase_libs}")

Pour configurer l'intégration de bureau , consultez Ajouter Firebase à votre projet C++ .

1. Suivez les instructions pour ajouter Firebase à votre projet Unity .

2. Utilisez l'interface Unity pour configurer votre projet afin de réduire les builds Android.

Vous devez réduire la construction pour éviter le message Error while merging dex archives .

L'option se trouve dans Paramètres du lecteur > Android > Paramètres de publication > Minify .

Les options peuvent différer selon les différentes versions d'Unity, alors reportez-vous à la documentation officielle d'Unity et au Guide de débogage Firebase Unity Build .

Si, après avoir activé la minification, le nombre de méthodes référencées dépasse toujours la limite, une autre option consiste à activer multidex dans :

mainTemplate.gradle si le modèle Gradle personnalisé sous Paramètres du lecteur est activé

ou le fichier build.gradle au niveau du module, si vous utilisez Android Studio pour créer le projet exporté.

1. Ajoutez le SDK d'administration Firebase à votre application :

npm install firebase-admin --save

2. Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les informations d'identification appropriées dans votre environnement.

1. Ajoutez le SDK Firebase Admin à votre application Go :

go get firebase.google.com/go

2. Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les informations d'identification appropriées dans votre environnement.

1. Les bibliothèques clientes du serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C# et Ruby) utilisent les informations d'identification par défaut de l'application Google pour l'authentification.

2. Installez et activez l' extension gRPC pour PHP, dont vous aurez besoin pour utiliser la bibliothèque client.

3. Ajoutez la bibliothèque PHP Cloud Firestore à votre application :
composer require google/cloud-firestore

1. Les bibliothèques clientes du serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C# et Ruby) utilisent les informations d'identification par défaut de l'application Google pour l'authentification.

2. Ajoutez la bibliothèque Cloud Firestore C# à votre application dans votre fichier .csproj :

<ItemGroup>
  <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
</ItemGroup>

3. Ajoutez ce qui suit à votre fichier Program.cs :
using Google.Cloud.Firestore;

1. Les bibliothèques clientes du serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C# et Ruby) utilisent les informations d'identification par défaut de l'application Google pour l'authentification.

2. Ajoutez la bibliothèque Cloud Firestore Ruby à votre application dans votre Gemfile :
gem "google-cloud-firestore"

3. Installez les dépendances depuis votre Gemfile en utilisant :
bundle install

(Facultatif) Prototyper et tester avec Firebase Local Emulator Suite

Pour les développeurs mobiles, avant de parler de la façon dont votre application écrit et lit depuis Cloud Firestore, présentons un ensemble d'outils que vous pouvez utiliser pour prototyper et tester la fonctionnalité Cloud Firestore : Firebase Local Emulator Suite. Si vous essayez différents modèles de données, optimisez vos règles de sécurité ou cherchez le moyen le plus rentable d'interagir avec le back-end, pouvoir travailler localement sans déployer de services en direct peut être une excellente idée.

Un émulateur Cloud Firestore fait partie de la suite d'émulateurs locaux, qui permet à votre application d'interagir avec le contenu et la configuration de votre base de données émulée, ainsi qu'éventuellement avec les ressources de votre projet émulé (fonctions, autres bases de données et règles de sécurité).

L'utilisation de l'émulateur Cloud Firestore ne nécessite que quelques étapes :

Une présentation détaillée impliquant Cloud Firestore et Cloud Functions est disponible. Vous devriez également jeter un œil à l'introduction de Local Emulator Suite .

Initialiser Cloud Firestore

Initialisez une instance de Cloud Firestore :

Ajouter des données

Cloud Firestore stocke les données dans des documents, qui sont stockés dans des collections. Cloud Firestore crée implicitement des collections et des documents la première fois que vous ajoutez des données au document. Vous n'avez pas besoin de créer explicitement des collections ou des documents.

Créez une nouvelle collection et un document à l'aide de l'exemple de code suivant.

// Add a new document with a generated ID
Future<DocumentReference> user_ref =
    db->Collection("users").Add({{"first", FieldValue::String("Ada")},
                                 {"last", FieldValue::String("Lovelace")},
                                 {"born", FieldValue::Integer(1815)}});

user_ref.OnCompletion([](const Future<DocumentReference>& future) {
  if (future.error() == Error::kErrorOk) {
    std::cout << "DocumentSnapshot added with ID: " << future.result()->id()
              << std::endl;
  } else {
    std::cout << "Error adding document: " << future.error_message() << std::endl;
  }
});

DocumentReference docRef = db.Collection("users").Document("alovelace");
Dictionary<string, object> user = new Dictionary<string, object>
{
	{ "First", "Ada" },
	{ "Last", "Lovelace" },
	{ "Born", 1815 },
};
docRef.SetAsync(user).ContinueWithOnMainThread(task => {
	Debug.Log("Added data to the alovelace document in the users collection.");
});

Ajoutez maintenant un autre document à la collection users . Notez que ce document inclut une paire clé-valeur (deuxième prénom) qui n'apparaît pas dans le premier document. Les documents d'une collection peuvent contenir différents ensembles d'informations.

db->Collection("users")
    .Add({{"first", FieldValue::String("Alan")},
          {"middle", FieldValue::String("Mathison")},
          {"last", FieldValue::String("Turing")},
          {"born", FieldValue::Integer(1912)}})
    .OnCompletion([](const Future<DocumentReference>& future) {
      if (future.error() == Error::kErrorOk) {
        std::cout << "DocumentSnapshot added with ID: "
                  << future.result()->id() << std::endl;
      } else {
        std::cout << "Error adding document: " << future.error_message()
                  << std::endl;
      }
    });

DocumentReference docRef = db.Collection("users").Document("aturing");
Dictionary<string, object> user = new Dictionary<string, object>
{
	{ "First", "Alan" },
	{ "Middle", "Mathison" },
	{ "Last", "Turing" },
	{ "Born", 1912 }
};
docRef.SetAsync(user).ContinueWithOnMainThread(task => {
	Debug.Log("Added data to the aturing document in the users collection.");
});

Lire des données

Utilisez la visionneuse de données dans la console Firebase pour vérifier rapidement que vous avez ajouté des données à Cloud Firestore.

Vous pouvez également utiliser la méthode " get " pour récupérer l'intégralité de la collection.

users_ref = db.collection("users")
docs = users_ref.stream()

for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")

Future<QuerySnapshot> users = db->Collection("users").Get();
users.OnCompletion([](const Future<QuerySnapshot>& future) {
  if (future.error() == Error::kErrorOk) {
    for (const DocumentSnapshot& document : future.result()->documents()) {
      std::cout << document << std::endl;
    }
  } else {
    std::cout << "Error getting documents: " << future.error_message()
              << std::endl;
  }
});

CollectionReference usersRef = db.Collection("users");
usersRef.GetSnapshotAsync().ContinueWithOnMainThread(task =>
{
  QuerySnapshot snapshot = task.Result;
  foreach (DocumentSnapshot document in snapshot.Documents)
  {
    Debug.Log(String.Format("User: {0}", document.Id));
    Dictionary<string, object> documentDictionary = document.ToDictionary();
    Debug.Log(String.Format("First: {0}", documentDictionary["First"]));
    if (documentDictionary.ContainsKey("Middle"))
    {
      Debug.Log(String.Format("Middle: {0}", documentDictionary["Middle"]));
    }

    Debug.Log(String.Format("Last: {0}", documentDictionary["Last"]));
    Debug.Log(String.Format("Born: {0}", documentDictionary["Born"]));
  }

  Debug.Log("Read all data from the users collection.");
});

Sécurisez vos données

Si vous utilisez le SDK des plates-formes Web, Android ou Apple, utilisez l'authentification Firebase et les règles de sécurité Cloud Firestore pour sécuriser vos données dans Cloud Firestore.

Voici quelques ensembles de règles de base que vous pouvez utiliser pour commencer. Vous pouvez modifier vos règles de sécurité dans l' onglet Règles de la console.

Avant de déployer votre application Web, Android ou iOS en production, prenez également des mesures pour vous assurer que seuls les clients de votre application peuvent accéder à vos données Cloud Firestore. Consultez la documentation App Check .

Si vous utilisez l'un des SDK du serveur, utilisez la gestion des identités et des accès (IAM) pour sécuriser vos données dans Cloud Firestore.

Regarder un didacticiel vidéo

Pour obtenir des conseils détaillés sur la prise en main des bibliothèques clientes mobiles Cloud Firestore, regardez l'un des didacticiels vidéo suivants :

Vous pouvez trouver plus de vidéos sur la chaîne YouTube Firebase .

Prochaines étapes

Approfondissez vos connaissances avec les sujets suivants :

# data[].attributes.attachment_link.title
Premiers pas avec Cloud Firestore | Firebase

# data[].attributes.attachment_link.description
Ce démarrage rapide vous montre comment configurer Cloud Firestore, ajouter des données, puis afficher les données que vous venez d'ajouter dans la console Firebase. Si vous ne l'avez pas déjà fait, créez un projet Firebase : dans la console Firebase , cliquez sur Ajouter un projet , puis suivez les instructions à l'écran pour créer un projet Firebase ou pour ajouter des services Firebase à un projet GCP existant.

# data[].attributes.body
IP de la camera : 192.168.20.37:88

user : dev_IA_P3

mdp : dev_IA_P3

# data[].attributes.body
Le feu permettant d'indiquer si c'est une pub, ou pas, ou peut-être ;) est piloté par le réseau, via une api.

Envoyez une requête HTTP à l'URL : http://192.168.20.95/ et utiliser les endpoint :

feuR pour le feu rouge

feuO pour le feu orange

feuV pour le feu vert

feuOff pour l'éteindre

# data[].attributes.body
Votre code devra être documenté en utilisant l'outil de documentation par les commentaires du code : Doxygen.

Le tuto ci-dessous vous montre sa mise en oeuvre...

Lien vers le tuto Doxygen : https://github.com/Olivier-hac/tuto-doxygen/blob/main/Génération%20automatique%20de%20documentation%20avec%20Doxygen.pdf

# data[].attributes.attachment_link.readable_text
Vous trouverez ci-après les adresses URL des flux vidéos ainsi que les API permettant de déclencher les mouvements pour les caméras rotatives.

Infos

[ip] = Doit être remplacé par l'adresse IP de la caméra telle que trouvée par l'utilitaire Foscam "IP Camera Tool". Nous vous recommandons de fixer cette IP au niveau de votre box Internet / routeur (menu DHCP).

[port] = Le port utilisé par votre caméra. Par défaut, si vous ne l'avez pas changé, il s'agit du port 88 mais il peut aussi s'agir du 80.

[utilisateur] = Le nom d'utilisateur que vous avez configuré sur votre caméra lors de la première mise en service.

[motdepasse] = Le mot de passe que vous avez configuré sur votre caméra lors de la première mise en service.

Flux vidéo SD/HD H264 (via RTSP)

Vous pouvez par exemple accéder à ce flux (vidéo + son) via le lecteur vidéo VLC.

flux principal / haute qualité : rtsp://[utilisateur]:[motdepasse]@[ip]:[port]/videoMain

flux secondaire / débit réduit : rtsp://[utilisateur]:[motdepasse]@[ip]:[port]/videoSub

La définition, la fluidité et le débit / taux de compression de chacun de ces deux flux peuvent être configurés via l'interface Web de la caméra.

Le port du flux RTSP peut être 80, 88 ou 554 suivant le modèle de la caméra et surtout sa version de firmware.

Sur les firmwares les plus récents, il est nécessaire d'activer le flux RTSP qui ne l'est plus par défaut. Pour cela, il faut aller sur la page web de configuration de la caméra, dans "réglages", "réseau" puis "onvif" et cocher la case "activé". Ce menu vous informera aussi sur le port utilisé pour RTSP, probablement le 554.

Flux vidéo SD MJPEG (via HTTP)

http://[ip]:[port]/cgi-bin/CGIStream.cgi?cmd=GetMJStream&usr=[utilisateur]&pwd=[motdepasse]

Attention : vous devez d'abord configurer le flux secondaire de la caméra IP Foscam en flux MJPEG

Snapshot (photo JPEG)

http://[ip]:[port]/cgi-bin/CGIProxy.fcgi?cmd=snapPicture2&usr=[utilisateur]&pwd=[motdepasse]

Rotation de la caméra

Haut : http://[ip]:[port]/cgi-bin/CGIProxy.fcgi?cmd=ptzMoveUp&usr=[utilisateur]&pwd=[motdepasse]

Bas : http://[ip]:[port]/cgi-bin/CGIProxy.fcgi?cmd=ptzMoveDown&usr=[utilisateur]&pwd=[motdepasse]

Gauche : http://[ip]:[port]/cgi-bin/CGIProxy.fcgi?cmd=ptzMoveLeft&usr=[utilisateur]&pwd=[motdepasse]

Droite : http://[ip]:[port]/cgi-bin/CGIProxy.fcgi?cmd=ptzMoveRight&usr=[utilisateur]&pwd=[motdepasse]

Voici en téléchargement, le pdf complet des API des caméras FOSCAM HD :

Mis à jour le : 02/10/2017 à 14:53 Auteur : Jérôme Massiaux, technicien domotique-store.fr

Recommandez cet article

Ces articles pourraient aussi vous intéresser

# data[].attributes.attachment_link.title
Tutoriels et Manuels DOMOTIQUE-STORE.FR - API des caméras FOSCAM HD

# data[].attributes.attachment_link.description
API des caméras IP FOSCAM HD Vous trouverez ci-après les adresses URL ...

# data[].attributes.body
NoSQL Collection Documents

Objectif

Créer une base de données NoSQL de type collection de documents pour stocker des informations liées à l'acquisition d'images, à l'application, aux développeurs, aux modèles d'IA, au site web, et aux logs.

Schéma de la base de données

Acquisition

versions: Liste des versions d'acquisition.

HP_acquisition: Haut-parleur d'acquisition.

Duree_salve: Durée de la salve (par exemple, 5).

nb_images_par_salves: Nombre d'images par salve (par exemple, 10).

donnees: Données d'acquisition.

IP_camera: Adresse IP de la caméra (par exemple, 192.168.20.15).

Port_camera: Port de la caméra (par exemple, 88).

Lien_flux_snapshot: Lien du flux snapshot.

Lien_flux_rtsp: Lien du flux RTSP.

username: Nom d'utilisateur (par exemple, greta).

password: Mot de passe (par exemple, greta).

Application

Versions: Liste des versions de l'application.

version: Version de l'application (par exemple, 1.0.0).

version_node: Version de Node.js utilisée (par exemple, 15.15.0).

template_utilise: Template utilisé (par exemple, React creative Team).

Infos développeur

Entreprise: Nom de l'entreprise (par exemple, Greta-cfa Besancon).

fonction: Fonction du développeur (par exemple, développeur).

nom_developpeur: Nom du développeur (par exemple, ranguis).

prenom_developpeur: Prénom du développeur (par exemple, jeremy).

Modèle IA

Versions: Liste des versions du modèle d'IA.

HP: Puissance du modèle.

fps: Fréquence d'images par seconde (par exemple, 20).

learning: Taux d'apprentissage (par exemple, 0.004).

infos_modele: Informations sur le modèle.

nom_modele: Nom du modèle (par exemple, MobileNet).

version: Version du modèle (par exemple, V2).

seuil_decision: Seuil de décision (par exemple, 70).

Site Web

titre_page: Titre de la page du site web (par exemple, "Pub NoPub").

url_publique: URL publique du site web (par exemple, "https://...").

Logs

historique: Historique des logs.

Metriques: Liste des métriques.

Metrique_1: Valeur de la métrique 1 (par exemple, 0.014).

Metrique_2: Valeur de la métrique 2 (par exemple, 70).

...: Autres métriques.

reference_salve_storage: Chemin vers le stockage de la salve.

resultats: Résultats des prédictions.

predictions_pub_par_images: Liste des prédictions pour les images publiques.

predictions_nopub_par_images: Liste des prédictions pour les images non publiques.

moyenne_pub: Moyenne des prédictions pour les images publiques.

moyenne_no_pub: Moyenne des prédictions pour les images non publiques.

Version_acquisition: Chemin vers le document de la version d'acquisition pour la salve.

Version_application: Chemin vers le document de la version d'application pour la salve.

version_modele_IA: Chemin vers le document de la version du modèle pour la salve.