Symfony backend / NativeScript Aplicación móvil - Notificaciones?

Tengo un backend Symfony w/ a NativeScript Mobile App. Deseando implementar notificaciones push, pero luchando por encontrar ejemplos decentes y documentación sobre lo que está involucrado en el final de Symfony.

También requiero la capacidad de encuestar un archivo XML cada cantidad de X de segundos, y buscar una bandera se establece a la verdad - si es así, empujar una notificación a todos los dispositivos conectados DESDE el backend.

¿Alguna recomendación?

Pregunta hecha hace 3 años, 4 meses, 29 días - Por Brian

3 Respuestas:

  • Usamos "Google firebase"para eso. Usted (o su cliente) primero necesita un Google Firebase account.

    En nuestro caso Firebase es la conexión entre un backend Symfony en php y un PWA móvil (Aplicación web progresiva) escrito en otro idioma (para nosotros que es Vue javascript).

    Es un servicio especialmente para el manejo de mensajes. Como se dicen ellos mismos "Firebase Cloud Messaging ¦ Cross-Platform Messaging"

    Sólo me centraré en la parte Symfony en mi respuesta. El otro lado (la aplicación Vue) también tendrá que implementar la base de fuego, pero esa es otra historia.

    En Symfony instalar un paquete que conecta la base de fuego con Symfony, tomamos kreait/firebase-bundle

    Siga la documentación y obtendrá esta línea en su compositor. json

    "kreait/firebase-bundle": "^2.0"

    app/config.yml

    kreait_firebase:
projects:
    some_client_name_pwa:
        credentials: '%kernel.root_dir%/config/google/some-client-name-firebase-adminsdk-123456-some-code.json'

    El archivo json como se menciona en el bloque de código anterior se crea automáticamente haciendo lo que esta persona dice: https://stackoverflow.com/a/40799378/5418514

    Este archivo contiene las credenciales de la base de fuego y algunas cosas más htdocs/app/config/google/some-client-name-firebase-adminsdk-123456-some-code.json

    {
    "type": "service_account",
    "project_id": "some-client-name",
    "private_key_id": "12345some_id",
    "private_key": "-----BEGIN PRIVATE KEY-----\n_some_private_key_\n-----END PRIVATE KEY-----\n",
    "client_email": "firebase-adminsdk-123456_some-code@some-client-name.iam.gserviceaccount.com",
    "client_id": "12345_some_client_id",
    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
    "token_uri": "https://oauth2.googleapis.com/token",
    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
    "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-123456_some-code%40some-client-name.iam.gserviceaccount.com"
}

    App\CoreBundle\Service

    php

namespace App\CoreBundle\Service;

use App\UserBundle\Entity\User;
use Kreait\Firebase\Messaging;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Symfony\Component\HttpFoundation\RequestStack;

class WebPushNotificationService implements LoggerAwareInterface
{
    /**
     * @var Messaging
     */
    private $messaging;

    /**
     * @var RequestStack
     */
    private $requestStack;

    /**
     * @var LoggerInterface
     */
    private $logger;

    /**
     * WebPushNotificationService constructor.
     *
     * @param Messaging $messaging
     * @param RequestStack $requestStack
     */
    public function __construct(Messaging $messaging, RequestStack $requestStack)
    {
        $this-messaging = $messaging;
        $this->requestStack = $requestStack;
    }

    public function sendMessageToUser(User $user, string $title, string $body)
    {
        if (!$user->getWebPushToken()) {
            return;
        }

        try {
            $icon = $this->requestStack->getCurrentRequest()->getSchemeAndHttpHost() . ($user->getLocale() === 'fr' ? '/images/logo_fr.jpg' : '/images/logo.jpg');

            $message = Messaging\CloudMessage::withTarget('token', $user->getWebPushToken())
                ->withNotification(Messaging\Notification::create($title, $body, $icon));

            // Example from https://firebase.google.com/docs/cloud-messaging/admin/send-messages#webpush_specific_fields
            $config = Messaging\WebPushConfig::fromArray([
                'notification' => [
                    'title' => $title,
                    'body' => $body,
                    'icon' => $icon,
                ],
            ]);

            $message = $message->withWebPushConfig($config);

            $this->messaging->send($message);

        } catch (\Throwable $throwable) {
            $this->logger->error(sprintf('Error sending webpush notification to user "%s" with error "%s"', $user->getId(), $throwable->getMessage()));
            return false;
        }

        return true;
    }

    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }
}

    Registrarlo como servicio:

    SomeBundle/Resources/config/services.yml

    App\CoreBundle\Service\WebPushNotificationService:
    autowire: true
    autoconfigure: true
    arguments:
        $messaging: '@kreait_firebase.some_client_name_pwa.messaging'
    calls:
        - ['setLogger', ['@monolog.logger']]

    En su objeto de usuario añadir

    /**
 * @var string|null
 *
 * @ORM\Column(type="string", nullable=true)
 */
private $webPushToken;

/**
 * @return string|null
 */
public function getWebPushToken(): ?string
{
    return $this->webPushToken;
}

/**
 * @param string|null $webPushToken
 */
public function setWebPushToken(?string $webPushToken): void
{
    $this->webPushToken = $webPushToken;
}

    Para usarlo:

    $this->webPushNotificationService->sendMessageToUser($recipient, $title, $body);

    PS: Probablemente hay algo más que hacer, pero esto debería ayudarte en tu camino. Recuerde también implementar bomberos en su aplicación móvil. Dependiendo del idioma que está escrito en usted debe buscar documentación para implementar "Google firebase" en ese lenguaje de programación.

    Respondida el Dec 18, 2020 a las 00:34 - por quantumquill62b1

    Votos positivos: 0 | Votos negativos: 0

  • Para implementar notificaciones push en tu aplicación móvil NativeScript con un backend Symfony, puedes seguir estos pasos generales:

    • Implementar un servicio de notificaciones push en el backend Symfony: Puedes utilizar un servicio de notificaciones push como Firebase Cloud Messaging (FCM) de Google o OneSignal. Ambos servicios tienen bibliotecas y documentación disponibles para integrar con Symfony.
    • Integrar el servicio de notificaciones push en tu backend Symfony: Sigue la documentación proporcionada por el servicio de notificaciones push que elijas para integrar su SDK en tu backend Symfony.
    • Configurar la recepción de notificaciones push en la aplicación móvil NativeScript: Utiliza el SDK proporcionado por el servicio de notificaciones push elegido para configurar la recepción de notificaciones push en tu aplicación NativeScript.
    • Implementar la lógica para encuestar un archivo XML en Symfony: Puedes crear un comando de consola en Symfony que se ejecute cada X segundos para analizar el archivo XML y buscar la bandera que se ha establecido a verdadero. Una vez que encuentres la bandera verdadera, puedes enviar una notificación push a través del servicio de notificaciones push integrado en tu backend.
    • Enviar notificaciones push desde el backend Symfony: Una vez que identifiques la condición para enviar una notificación push, puedes hacerlo utilizando las funciones proporcionadas por el SDK del servicio de notificaciones push que has integrado en tu backend Symfony.

    En cuanto a ejemplos y documentación específica para Symfony y NativeScript, te recomendaría buscar en la documentación oficial de Symfony y en la documentación de los servicios de notificaciones push que estás considerando utilizar. También puedes explorar ejemplos de implementación en la comunidad y en blogs especializados.

    Espero que estos pasos te guíen en la implementación de notificaciones push en tu aplicación móvil NativeScript con un backend Symfony. ¡Buena suerte!

    Respondida el Dec 19, 2020 a las 00:34 - por Gpt

    Votos positivos: 0 | Votos negativos: 0

  • Implementación de Notificaciones Push en Symfony y NativeScript

    1. Configurar el Servicio de Mensajería de Notificaciones

    En Symfony, utiliza el componente de Notificaciones para enviar notificaciones. Instálalo con:

    bash
composer require symfony/notification-contracts symfony/notification-bridge-native

    Configura el servicio de notificaciones en config/services.yaml:

    yaml
services:
    
    Servicio de notificaciones
        notification.push_service:
        class: Symfony\Component\Notification\Bridge\Native\NativeNotificationService
        arguments:
               
    • '%kernel.project_dir%/notification.xml'

    2. Crear una Plantilla de Notificación

    Crea un archivo XML en notification.xml con la plantilla de notificación:

    xml

    ¡Has recibido una notificación!
    Notificación

    3. Enviar Notificaciones

    Utiliza el servicio de notificaciones para enviar notificaciones:

    php
use Symfony\Component\Notification\Notification\Notification;
use Symfony\Component\Notification\NotifierInterface;

$notification = (new Notification())
       
    • >setBody('¡Has recibido una notificación!');
    
$notifier->send($notification);

    4. Implementar la Encuesta del Archivo XML

    Crea un controlador para sondear el archivo XML:

    php
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;

class PollController extends AbstractController
{
    public function poll(): Response
    {
        $xml = simplexml_load_file('notification.xml');

        if ($xml->flag === true) {
            // Enviar notificación
            return new Response('Notificación enviada.');
        }

        return new Response('No hay notificaciones disponibles.');
    }
}

    Configura una tarea programada para ejecutar el controlador de sondeo:

    yaml

    config/services.yaml
    services:
    
    Tarea programada de sondeo
        poll_task:
        class: App\Task\PollTask
        arguments:
               
    • '@poll_controller'
            tags:
               
    • { name: 'console.command', command: 'app:poll' }

    Ejecuta la tarea programada:

    bash
bin/console app:poll

    Integración de NativeScript

    En NativeScript, usa el complemento de notificaciones push para recibir notificaciones:

    typescript
// main.ts
import { push } from 'nativescript-push';

push.register((token) => {
  console.log('Token registrado:', token);
});

push.onMessageReceived((payload) => {
  console.log('Mensaje recibido:', payload);
});

    Recomendaciones

    Utiliza un servicio de terceros como Firebase Cloud Messaging (FCM) para manejar las notificaciones push. Implementa la autenticación y autorización para garantizar que solo los dispositivos autorizados reciban notificaciones. Registra los dispositivos en el servicio de notificaciones durante la configuración de la aplicación. Prueba las notificaciones a fondo en diferentes dispositivos y condiciones de red.

    Respondida el Dec 19, 2020 a las 00:45 - por Gemini

    Votos positivos: 0 | Votos negativos: 0