O que são notificações push?

As notificações push são um canal de comunicação poderoso que foi introduzido pela Apple em 2009. Desde então, sua popularidade disparou e elas se tornaram uma parte essencial da maioria das campanhas de marketing. As notificações podem ser usadas para impulsionar o engajamento, aumentar o uso do aplicativo, influenciar as conversões e muito mais!

Neste artigo, aprenderemos sobre notificações push, seus benefícios, casos de uso, tipos de notificações e o que fazer e o que não fazer. Além disso, veremos como enviar notificações push para dispositivos Android usando o Back4app, um dos melhores provedores de mBaaS.

O que é uma notificação por push?

Uma notificação push é uma mensagem curta ou um alerta que pode ser enviado diretamente para o dispositivo móvel do cliente, navegador da Web, dispositivo vestível ou qualquer outro dispositivo compatível com notificações. Elas são usadas como um canal de comunicação rápido que permite que as empresas enviem lembretes, atualizações, mensagens sensíveis ao tempo, promoções e muito mais.

As notificações push são um serviço opt-in, o que significa que o cliente precisa concordar em receber notificações. O consentimento geralmente é obtido em uma simples mensagem pop-up ou pela instalação do aplicativo móvel do editor.

As notificações por push são compostas de vários elementos. Sua estrutura e aparência variam ligeiramente, dependendo do dispositivo e do sistema operacional do cliente. Em geral, elas podem conter texto, emojis, imagens e botões ou os chamados CTAs que executam uma ação específica ao serem clicados.

Um exemplo de notificação por push em um dispositivo Android tem a seguinte aparência:

Por que usar notificações por push?

As notificações push são uma ferramenta multiuso. Elas podem ser usadas para marketing, mensagens sensíveis ao tempo, alertas de segurança, atualizações e muito mais. Vamos dar uma olhada em alguns dos casos de uso mais comuns.

Promoções e ofertas

As empresas podem aproveitar as notificações push para enviar ofertas promocionais e descontos aos usuários, incentivando-os a fazer compras. Além disso, elas podem personalizar as notificações push para torná-las mais relevantes e eficazes.

Redução de carrinhos abandonados

Se você possui uma loja de comércio eletrônico, as notificações push podem ajudá-lo a reduzir os carrinhos abandonados. Depois que um carrinho tiver sido abandonado por alguns dias, você poderá cutucar o usuário com uma notificação por push oferecendo um desconto adicional.

Interações sociais

As notificações push são ótimas para a retenção de usuários. A maioria dos aplicativos sociais, como Facebook, Instagram e Twitter, envia uma notificação sempre que outro usuário interage com você. Por exemplo: curte sua publicação, comenta sua publicação, envia uma mensagem e assim por diante.

Atualizações e lembretes

As notificações por push podem ser uma ferramenta útil para receber atualizações e lembretes de coisas como eventos, compromissos e prazos.

Segurança

As notificações por push também podem ser usadas para fins de segurança. Algumas empresas enviam aos clientes uma notificação por push sempre que alguém faz login em sua conta. Além disso, você pode usar as notificações por push para iniciar uma confirmação de 2FA.

Quais são os benefícios de usar as notificações por push?

Mencionamos muitos dos benefícios da notificação por push na seção anterior. Para resumir, os benefícios incluem:

• Aumento do envolvimento do usuário
• Maior retenção de usuários
• Taxas de conversão mais altas
• Atendimento ao cliente aprimorado
• Aumento das vendas e da receita
• Melhoria da experiência do usuário

Quais são os tipos de notificação por push?

Há três tipos de notificações por push: notificações para celular, notificações para a Web e notificações para desktop.

Notificação push móvel

As notificações push para celular são o tipo de notificação push mais usado e conhecido. Elas podem aparecer de várias formas, inclusive na barra de status, na gaveta de notificações, na notificação heads-up e na tela de bloqueio.

Elas podem conter um ícone pequeno, nome do aplicativo, registro de data e hora, ícone grande, título, texto e botões. As notificações móveis podem ser organizadas em diferentes canais com base em seu conteúdo e importância.

As notificações push móveis são normalmente enviadas usando um serviço de notificação push, como o Apple Push Notification Service (APNS) para dispositivos iOS e o Firebase Cloud Messaging (FCM) para dispositivos Android. Mais informações sobre os serviços de notificação por push mais adiante no tutorial.

Notificação por push da Web

As notificações por push baseadas na Web são notificações que podem ser enviadas por sites para o navegador do usuário, mesmo quando o navegador não está aberto. Elas aparecem na gaveta de notificações da área de trabalho e na tela inicial do navegador.

A primeira versão das notificações por push da Web foi lançada pelo Google em 2014. Atualmente, elas são compatíveis com a maioria dos navegadores da Web modernos, incluindo o Google Chrome, o Mozilla Firefox e o Microsoft Edge.

Em contraste com as notificações móveis, essas notificações são fornecidas por meio da API Push do navegador.

Notificação por push no desktop

As notificações push de desktop são semelhantes às notificações push da Web. A principal diferença entre elas é como são enviadas. Enquanto as notificações da Web são enviadas por um site ou um aplicativo da Web, as notificações de desktop são enviadas por um aplicativo instalado no computador.

Eles aparecem na gaveta de notificações e são compatíveis com a maioria dos sistemas operacionais modernos.

O que faz uma boa notificação por push?

Em 2023, um usuário típico de smartphone receberá cerca de 50 notificações por dia. A maioria das notificações não é lida e é ignorada. Se você deseja que sua campanha de notificação por push seja mais bem-sucedida, considere as dicas a seguir.

Personalização

Adaptar as notificações aos interesses e preferências dos usuários pode torná-las mais relevantes e chamar a atenção. Isso pode melhorar a retenção, o envolvimento e a fidelidade do usuário. Além disso, pode aumentar a receita da sua empresa, incentivando os usuários a realizar as ações desejadas por meio de CTAs.

Use mídia avançada e emojis

Para tornar suas notificações mais envolventes e interessantes, certifique-se de incluir imagens e emojis relevantes. Estudos demonstraram que imagens e emojis podem aumentar muito as taxas de cliques.

Se você optar por emojis, certifique-se de não usá-los em excesso. Use no máximo um ou dois emojis no início ou no final da notificação.

Tempo certo para eles

É importante que você cronometre corretamente suas notificações push. Antes de enviar as notificações, certifique-se de conhecer sua base de clientes. Se seus clientes vivem em fusos horários diferentes, você pode dividi-los em vários grupos com base em seus fusos horários e, em seguida, enviar as notificações grupo por grupo.

A pesquisa da Notix descobriu que as notificações enviadas entre:

1. 8:00 a.m. e 11:00 a.m. têm uma taxa de cliques de 5,55%
2. 11:00 a.m. e 8:00 p.m. têm uma taxa de cliques de 7%
3. 8:00 p.m. e 11:00 p.m. têm uma taxa de cliques de 10,4%

Incluir CTAs

As notificações push devem comunicar claramente sua intenção e o que o usuário deve fazer em seguida. Por exemplo: se você acabou de publicar um novo artigo, certifique-se de incluir o link do artigo; se houver um novo produto disponível em sua loja, adicione um botão “Comprar agora”.

Lembre-se: Uma boa notificação push é relevante, envolve o usuário e agrega valor a ele.

O que evitar ao enviar notificações por push?

Embora as notificações push sejam uma ferramenta poderosa para envolver os usuários e gerar conversões, há algumas situações em que elas devem ser evitadas. Certifique-se de não fazê-lo:

1. Anuncie outro produto
2. Enviar muitas notificações
3. Enviar notificações irrelevantes ou sem sentido
4. Tente adquirir usuários por meio de notificações
5. Sobrecarregar seus usuários

O que é um serviço de notificação por push?

Um serviço de notificação por push é um serviço que permite que desenvolvedores de terceiros enviem notificações por push para os dispositivos de seus clientes por meio de uma API ou de um painel. Eles funcionam estabelecendo uma conexão entre o aplicativo ou site e o dispositivo do cliente. O serviço de notificação por push usa um identificador exclusivo para cada dispositivo para garantir que a mensagem seja entregue somente ao destinatário pretendido.

As funcionalidades típicas do serviço de notificação por push incluem o gerenciamento de clientes e públicos, o gerenciamento de notificações (incluindo pushs anteriores), o agendamento de notificações e a análise (taxa de cliques, entregas etc.).

Alguns exemplos de serviços de notificação por push são:

1. Firebase Cloud Messaging (FCM)
2. Apple Push Notification Service (APNS)
3. Amazon Simple Notification Service (SNS)
4. Back4app (Parse) Push Notifications
5. OneSignal

Como enviar uma notificação por push?

Esta seção do artigo aborda como enviar notificações push para dispositivos Android usando o Back4app.

Pré-requisitos

• Você precisa ter o Android Studio instalado
• Conhecimento básico do desenvolvimento de aplicativos Android
• Um projeto do Android Studio baseado no Gradle

Objetivos

1. Criar um aplicativo Back4app
   • Instalar e configurar o Parse SDK para Android
   • Inicialize o Parse com o ID do aplicativo e a chave do cliente
2. Criar um projeto e um aplicativo do Firebase
   • Instalar o SDK do Firebase
3. Vincule o Firebase e o Back4app por meio do ID do remetente do GCM e da chave do servidor do GCM
4. Configure as permissões do Android e registre um serviço e um receptor para notificações.
5. Enviar notificações push por meio do painel do Back4app ou do Cloud Code

O que é o Back4app?

O Back4app é um excelente provedor de Backend como Serviço (BaaS) que permite que os desenvolvedores se concentrem em seu aplicativo sem se preocupar com o backend ou a infraestrutura subjacente. Ele foi desenvolvido com base em tecnologia de código aberto, como Parse, GraphQL, Node.js e Redis.

O Back4app é fácil de usar, tem um painel de controle elegante e uma interface de linha de comando (CLI) para usuários mais avançados e automação de tarefas.

A plataforma tem vários recursos incorporados, incluindo:

• Banco de dados do tipo planilha
• Autenticação e autenticação social
• Notificações push e por e-mail
• Código de nuvem e empregos
• Gerenciamento de usuários
• Recursos de segurança

A Back4app tem um modelo de preços simples. Eles também oferecem uma camada gratuita generosa que pode ser usada para experimentar a plataforma ou até mesmo hospedar pequenos aplicativos.

Para saber mais sobre o Back4app, confira Por que usar o Back4app?

Criar o aplicativo Back4app

Se você já criou um aplicativo Back4app, instalou o Parse SDK e configurou seu projeto Android, fique à vontade para pular a seção!

Para trabalhar com o Back4app, primeiro precisamos criar um aplicativo. Ao fazer login no seu painel, você verá a lista de seus aplicativos. Clique em “Build new app” (Criar novo aplicativo) para iniciar o processo de criação do aplicativo.

Selecione “Backend as a Service”, digite o nome do aplicativo, selecione “NoSQL Database” como banco de dados e, por fim, clique em “Create”.

A Back4app levará alguns minutos para preparar tudo o que é necessário para o seu aplicativo, como o banco de dados, a camada de aplicativos, o dimensionamento, os backups e a segurança.

Quando o aplicativo estiver pronto, você será redirecionado para o painel de controle do aplicativo.

Em seguida, selecione “App Settings > Security & Keys” (Configurações do aplicativo > Segurança e chaves) na barra lateral e anote seu “Application ID” (ID do aplicativo) e “Client key” (chave do cliente). Precisaremos delas para conectar nosso aplicativo Android aos servidores da Back4app.

Instalar o Parse SDK

Para que nosso aplicativo se comunique com os servidores do Back4app, precisamos instalar o Parse SDK.

O processo que usaremos requer o Android SDK 27 ou superior. Antes de instalar o Parse, navegue até app/build.gradle e certifique-se de que compileSdk e targetSdk estejam definidos com as versões corretas:

// app/build.gradle

android {
    namespace "com.back4app.push"
    compileSdk 33  // <-- check this line

    defaultConfig {
        applicationId "com.back4app.push"
        minSdk 27
        targetSdk 33   // <-- check this line
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    // ...
}

Para acessar os pacotes de software mais recentes, vamos instalar o repositório de pacotes JitPack.

Navegue até o settings.gradle e adicione o repositório do JitPack ao dependencyResolutionManagement da seguinte forma:

// settings.gradle

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url "https://jitpack.io" }   // new
    }
}
rootProject.name = "back4app-push-notifications"
include ":app"

Em seguida, navegue até app/build.gradle e adicione as seguintes dependências:

// app/build.gradle

dependencies {
    implementation "com.parse.bolts:bolts-android:1.4.0"
    implementation "com.github.parse-community.Parse-SDK-Android:parse:4.2.0"
    implementation "com.github.parse-community.Parse-SDK-Android:fcm:4.2.0"
    // ...
}

Verifique se há uma versão mais recente disponível no JitPack e, em caso afirmativo, atualize-a.

Para que o Parse funcione, precisamos habilitar o acesso à Internet em nosso aplicativo. Além disso, temos de fornecer o “Application ID” e a “Client key” da seção anterior. Navegue até AndroidManifest.xml e modifique-o da seguinte forma:

<!-- app/src/main/AndroidManifest.xml -->

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <!-- new -->
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    <!-- end of new -->

    <application>
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

            <meta-data
                android:name="android.app.lib_name"
                android:value="" />

            <!-- new -->
            <meta-data
                android:name="com.parse.SERVER_URL"
                android:value="@string/back4app_server_url" />
            <meta-data
                android:name="com.parse.APPLICATION_ID"
                android:value="@string/back4app_app_id" />
            <meta-data
                android:name="com.parse.CLIENT_KEY"
                android:value="@string/back4app_client_key" />
            <!-- end of new -->

        </activity>
    </application>
</manifest>

Por fim, vá para strings.xml e adicione as strings que acabamos de usar:

<!-- app/src/main/res/values/strings.xml -->

<resources>
    <string name="app_name">back4app-push-notifications</string>
    <string name="back4app_server_url">https://parseapi.back4app.com</string>
    <string name="back4app_app_id">YOUR_PARSE_APP_ID</string>
    <string name="back4app_client_key">YOUR_PARSE_CLIENT_KEY</string>
</resources>

Certifique-se de substituir YOUR_PARSE_APP_ID e YOUR_PARSE_CLIENT_KEY por sua ID e chave reais.

Inicializar o Parse

Para inicializar o Parse, usaremos a classe Application do Android.

A classe Application fornece acesso global aos recursos e ao estado de todo o aplicativo. Ela é instanciada antes de qualquer outra classe quando o processo do aplicativo é iniciado e pode ser usada para gerenciar eventos do ciclo de vida do aplicativo, inicializar variáveis globais e implementar comportamento personalizado

Para saber mais sobre a classe Application, dê uma olhada na documentação oficial.

Navegue até a pasta onde está localizado o MainActivity.kt e crie um novo arquivo chamado App.kt com o seguinte conteúdo:

// app/src/main/java/.../App.kt

package com.back4app.push

import android.app.Application
import com.parse.Parse

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId(getString(R.string.back4app_app_id))
                .clientKey(getString(R.string.back4app_client_key))
                .server(getString(R.string.back4app_server_url))
                .build()
        )
    }
}

Em seguida, informe ao Android para usar a classe Application recém-criada, definindo o android:name do aplicativo no AndroidManifest.xml da seguinte forma:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <application
        android:name=".App"
    >
        <!-- ... -->
    </application>
</manifest>

Seu aplicativo agora deve estar conectado ao Back4app. Para garantir que tudo funcione, tente executar o aplicativo e verifique se há erros nos registros.

Criar projeto e aplicativo do Firebase

As etapas a seguir exigirão que você tenha uma conta do Firebase. Se ainda não tiver uma, inscreva-se com sua conta do Google.

Navegue até o console do Firebase e clique em “Create a project” (Criar um projeto).

Dê a ele um nome personalizado, eu vou chamar o meu de back4app-push-notifications.

Aceite os termos e condições, ative o Google Analytics e pressione “Create project” (Criar projeto).

Aguarde até que o Firebase provisione seu projeto e prepare tudo o que for necessário. Quando isso for feito, você será redirecionado para o painel do projeto.

Em seguida, crie um novo aplicativo clicando no ícone do Android.

Insira os seguintes detalhes:

1. Nome do pacote Android: use o nome do seu pacote (por exemplo, com.back4app.push)
2. Apelido do aplicativo (opcional): Digite um apelido personalizado
3. Chave de assinatura de depuração: Deixe em branco (ou obtenha sua chave seguindo este artigo)

Por fim, baixe o arquivo google-services.json e coloque-o na pasta do aplicativo.

Pule as seções “Adicionar Firebase SDK” e “Próximas etapas”, pois faremos isso na próxima seção do artigo.

Instalar o Firebase SDK

Para instalar o Firebase SDK, navegue até o build.gradle no nível do projeto e adicione a propriedade buildscript da seguinte forma:

// build.gradle

buildscript {
    dependencies {
        classpath "com.google.gms:google-services:4.3.15"
    }
}

Em seguida, adicione os seguintes plug-ins e dependências ao seu app/build.gradle:

// app/build.gradle

plugins {
    id "com.android.application"
    id "org.jetbrains.kotlin.android"
    id "com.google.gms.google-services"  // new
}

dependencies {
    implementation platform("com.google.firebase:firebase-bom:31.2.2")  // new
    implementation "com.google.firebase:firebase-analytics-ktx"  // new
    // ....
}

Sincronize suas configurações do Gradle.

Vincular o projeto Firebase ao aplicativo Back4app

Para vincular o projeto do Firebase ao aplicativo Back4app, primeiro precisamos obter o ID do remetente do GCM e a chave do servidor do GCM. Para fazer isso, abra o console do Firebase, clique no ícone de engrenagem e, em seguida, em “Project Settings” (Configurações do projeto).

Selecione “Cloud Messaging” (Mensagens na nuvem) na navegação superior.

Parse de notificações push requer a API Cloud Messaging, que está desativada por padrão. Para ativá-la, use a opção mais e, em seguida, clique em “Gerenciar API no Google Cloud Console”. Clique em “Enable API” (Ativar API) e aguarde alguns segundos para que o Google a ative.

Depois que a API for ativada com êxito, feche a guia atual e navegue de volta para as configurações do Cloud Messaging. Anote seu “Sender ID” (ID do remetente) e “Server Key” (chave do servidor).

Em seguida, navegue até o painel de controle do aplicativo Back4app e selecione “Configurações do aplicativo > Configurações do servidor” na barra lateral. Role a tela para baixo até ver “Android Push notification” e clique em “Settings” (Configurações).

Clique em “Edit” (Editar), digite seu “Sender ID” (ID do remetente) e “Server key” (chave do servidor) e salve.

Seu projeto Firebase e o aplicativo Back4app agora estão conectados.

Configurar o aplicativo para notificações push

A última coisa que temos de fazer antes de enviar notificações é configurar nosso aplicativo Android. Teremos que fazer isso:

1. Defina o ID do remetente do GCM e adicione permissões no AndroidManifest.xml
2. Adicionar um serviço e um receptor ao AndroidManifest.xml
3. Criar um ParseInstallation no App.kt

Navegue até seu AndroidManifest.xml e modifique-o da seguinte forma:

<!-- app/src/main/AndroidManifest.xml -->

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <!-- new -->
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.VIBRATE" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
    <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
    <!-- end of new -->

    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.INTERNET" />

    <application>
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

            <meta-data
                android:name="android.app.lib_name"
                android:value="" />
            <meta-data
                android:name="com.parse.SERVER_URL"
                android:value="@string/back4app_server_url" />
            <meta-data
                android:name="com.parse.APPLICATION_ID"
                android:value="@string/back4app_app_id" />
            <meta-data
                android:name="com.parse.CLIENT_KEY"
                android:value="@string/back4app_client_key" />

            <!-- new -->
            <meta-data
                android:name="com.parse.push.gcm_sender_id"
                android:value="YOUR_GCM_SENDER_ID" />
            <!-- end of new -->

        </activity>

        <!-- new -->
        <service
            android:name="com.parse.fcm.ParseFirebaseMessagingService"
            android:exported="false">
            <intent-filter>
                <action android:name="com.google.firebase.MESSAGING_EVENT" />
            </intent-filter>
        </service>

        <receiver
            android:name="com.parse.ParsePushBroadcastReceiver"
            android:exported="false">
            <intent-filter>
                <action android:name="com.parse.push.intent.RECEIVE" />
                <action android:name="com.parse.push.intent.OPEN" />
                <action android:name="com.parse.push.intent.DELETE" />
            </intent-filter>
        </receiver>
        <!-- end of new -->
    </application>
</manifest>

Certifique-se de substituir YOUR_GCM_SENDER_ID por sua ID real de remetente do GCM.

Seu AndroidManifest.xml final deve ter a seguinte aparência.

Em seguida, navegue até seu App.kt e adicione o seguinte código na parte inferior de onCreate():

// app/src/main/java/.../App.kt

import com.parse.ParseInstallation

class App : Application() {
    override fun onCreate() {
        // ...

        val installation = ParseInstallation.getCurrentInstallation()
        installation.put("GCMSenderId", "YOUR_GCM_SENDER_ID")
        installation.put("channels", listOf("news", "updates"))
        installation.saveInBackground()
    }
}

Certifique-se de inserir sua ID real de remetente do GCM. Você também pode modificar os nomes dos canais.

Esse código cria um ParseInstallation e o salva no banco de dados. Além disso, ele configura os canais de notificação, no nosso caso, notícias e atualizações. Esses canais podem ser usados para enviar diferentes tipos de notificações via Cloud Code.

Ótimo, configuramos com sucesso nosso aplicativo Android para notificações por push.

Enviar notificações push

Painel de controle do Back4app

É fácil enviar uma notificação por push por meio do painel do Back4app. Essa abordagem é adequada para o envio manual de notificações push únicas.

Primeiro, selecione “More > Push > Send New Push” na barra lateral e, em seguida, preencha o formulário.

Por fim, clique no botão “Send push”.

Sugiro que você use o formato JSON, pois ele permite que você especifique o título da notificação por meio do título e o corpo por meio do alerta.

Código de nuvem

O Cloud Code pode ser usado para enviar notificações por push de forma programática. Além disso, você pode usá-lo para agendar notificações push ou enviar notificações push em eventos específicos.

Para enviar uma notificação por push via Cloud Code, selecione “Cloud Code > Functions & Web Hosting” na barra lateral e adicione o seguinte código ao main.js:

// cloud/main.js

Parse.Cloud.define("pushTest", (request) => {
    return Parse.Push.send({
        channels: ["news"],
        data: {
            title: "Cloud Code",
            alert: "This push notification was sent via Cloud Code.",
        }
    }, { useMasterKey: true });
});

Implante o código clicando no botão “Deploy” (Implantar).

Por fim, acione a função de nuvem por meio de uma chamada REST:

curl --location --request POST 'https://parseapi.back4app.com/functions/pushTest' \
--header 'X-Parse-Application-Id: YOUR_APPLICATION_ID' \
--header 'X-Parse-REST-API-Key: YOUR_REST_KEY' \
--header 'Content-Type: application/json'

O ID do aplicativo e a chave REST podem ser obtidos em “App Settings > Security & Keys” (Configurações do aplicativo > Segurança e chaves).

Para agendar notificações por push, dê uma olhada em Cloud Jobs.

Conclusão

Neste artigo, falamos sobre notificações por push, seus benefícios, tipos de notificação e o que fazer e o que não fazer. Além disso, você aprendeu a configurar seu aplicativo Android para enviar suas notificações push via Back4app.

O código-fonte final está disponível em um repositório do GitHub.

Etapas futuras

1. Se quiser agendar suas notificações ou direcionar para usuários específicos, consulte os documentos do Parse.
2. Para saber como enviar notificações por push para dispositivos iOS, consulte a documentação oficial.
3. Para saber mais sobre o Cloud Code, dê uma olhada em O que é FaaS na computação em nuvem?

PERGUNTAS FREQUENTES