PIM VIII

Prévia do material em texto

UNIVERSIDADE PAULISTA
 
BRUNO ANHEZINI
 
 
 
 
 
 
 
 
PIM VIII
PIM VIII
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Polo Americana
2024
BRUNO ANHEZINI
 
 
 
 
 
 
 
 
PIM VIII
PIM VIII
 
 
Projeto integrado multidisciplinar apresentado ao
curso de Análise e Desenvolvimento de Sistemas,
área de tecnologia, da UNIVERSIDADE
PAULISTA, como requisito parcial para a
conclusão das disciplinas em Análise e
Desenvolvimento de Sistemas.
 
 
 
 
Orientador: ANDERSON PASSINI
 
 
 
 
 
 
 
 
 
 
 
 
 
Polo Americana
2024
RESUMO
O projeto aborda o desenvolvimento de um sistema de streaming de conteúdo
multimídia, composto por uma Web API, um protótipo em .NET MAUI e um aplicativo
Android, projetados para atender a diferentes públicos. O objetivo principal foi criar
uma solução integrada que permitisse a gestão de playlists e conteúdos por
criadores, além de oferecer aos usuários finais uma interface para explorar, consumir
e interagir com o material disponível. Para isso, foram utilizadas tecnologias como
ASP.NET Core, para a criação de uma API RESTful robusta e segura, e .NET MAUI,
que proporcionou uma interface multiplataforma otimizada para os criadores de
conteúdo. O aplicativo Android foi desenvolvido com foco na navegação eficiente,
reprodução de conteúdos multimídia e interação social. 
 
A metodologia incluiu uma etapa inicial de planejamento, onde foram levantados
requisitos e modelada a estrutura do banco de dados. O desenvolvimento seguiu um
fluxo sequencial, iniciando pela implementação da Web API e avançando para os
componentes de interface. Testes rigorosos foram realizados, abrangendo
validações unitárias, de integração e de interface, garantindo a confiabilidade e o
desempenho do sistema. A API foi documentada com Swagger, facilitando sua
integração e entendimento. Como resultado, o sistema apresentou alto
desempenho, com endpoints responsivos e uma experiência de uso intuitiva. O
projeto conclui com sucesso a proposta de entregar uma plataforma escalável e
eficiente para gestão e consumo de conteúdo multimídia.
Palavras-chave: Streaming; Multimídia; API; Aplicativo Android; .NET MAUI.
ABSTRACT
This project focuses on the development of a multimedia streaming system,
comprising a Web API, a .NET MAUI prototype, and an Android application, designed
to meet the needs of different user groups. The main objective was to create an
integrated solution enabling content creators to manage playlists and multimedia
files, while providing end users with an interface to explore, consume, and interact
with the available content. Technologies such as ASP.NET Core were used to
develop a robust and secure RESTful API, and .NET MAUI was employed to build an
optimized cross-platform interface for content creators. The Android application was
designed with an emphasis on efficient navigation, multimedia playback, and social
interaction. 
 
The methodology included an initial planning phase to gather requirements and
model the database structure. The development followed a sequential flow, starting
with the Web API implementation and progressing to the user-facing components.
Rigorous testing was conducted, encompassing unit, integration, and interface
validations to ensure system reliability and performance. The API was documented
using Swagger, facilitating integration and understanding. As a result, the system
demonstrated high performance, with responsive endpoints and an intuitive user
experience. The project successfully delivers a scalable and efficient platform for
multimedia content management and consumption.
Keywords: Streaming; Multimedia; API; Android Application; .NET MAUI.
1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
SUMÁRIO
INTRODUÇÃO 7
DESENVOLVIMENTO 9
Pré-Projeto 9
Implementação da Web API em C# 10
Configuração Inicial 10
Estrutura do Banco de Dados 11
Relacionamentos e Normalização 11
Endpoints Implementados 12
Segurança e Autenticação 15
Documentação com Swagger 16
Interface Gráfica 17
Estrutura do Projeto 18
Funcionalidades Implementadas 18
Tela Inicial 19
Simulação de Upload de Conteúdo 20
Aplicativo Android 21
Estrutura do Projeto 22
Funcionalidades Implementadas 23
Testes e Validação 26
Testes Unitários 26
Testes de Integração 27
Testes de Interface 27
Ferramentas de Teste 27
Relatório de Resultados 28
CONCLUSÃO 29
REFERÊNCIAS 31
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LISTA DE ILUSTRAÇÕES
Código 1 — Arquivo de Configuração 11
Código 2 — Classe de Contexto para o Entity Framework Core 12
Código 3 — Controller para Usuários 14
Código 4 — Serviço para Geração de Token 16
Código 5 — Configuração do Swagger 17
Código 6 — Model 18
Código 7 — ViewModel para Gerenciar Playlists 19
Código 8 — XAML da Tela Inicial 20
Código 9 — Lógica de Upload 21
Código 10 — Classe Playlist 24
Código 11 — Listagem de Playlists 25
Código 12 — Integração com Player 26
LISTA DE ABREVIATURAS E SIGLAS
API Application Programming Interface
JWT JSON Web Token
ORM Object-Relational Mapping
ASP.NET Active Server Pages .NET
MAUI Multi-platform App UI
CRUD Create, Read, Update, Delete
XML eXtensible Markup Language
XAML eXtensible Application Markup Language
1 INTRODUÇÃO
O desenvolvimento de sistemas de streaming de conteúdo multimídia tornou-
se essencial em um mundo onde o consumo digital está em constante crescimento.
Este projeto tem como objetivo criar uma solução integrada que atenda às
necessidades de diferentes públicos, como criadores de conteúdo, que necessitam
de ferramentas para gerenciar suas produções e monitorar métricas de
desempenho, e usuários finais, que buscam uma experiência rica e intuitiva no
consumo desses conteúdos. Ao explorar tecnologias modernas e estratégias de
desenvolvimento eficazes, o projeto visa não apenas atender às expectativas
funcionais, mas também apresentar uma abordagem inovadora e escalável. 
 
O tema é relevante, pois plataformas de streaming desempenham um papel
central na distribuição de informações e entretenimento. Empresas que investem em
soluções tecnológicas avançadas garantem não apenas eficiência operacional, mas
também um impacto significativo na satisfação dos usuários. Neste contexto, o
presente estudo destaca a importância de uma arquitetura bem planejada e de
tecnologias que garantam flexibilidade, segurança e desempenho. 
 
O problema abordado envolve a necessidade de criar um sistema completo
que integre ferramentas para upload e gestão de conteúdos, uma interface
multiplataforma e um aplicativo intuitivo, garantindo sincronização entre as partes e
uma experiência fluida. Para resolver essa questão, foi adotada uma abordagem
metodológica que incluiu levantamento de requisitos, modelagem de banco de
dados, implementação e validação rigorosa das funcionalidades desenvolvidas. 
 
O projeto foi dividido em etapas para facilitar a execução. Inicialmente, foi
realizada a análise e documentação dos requisitos. Em seguida, cada módulo foi
desenvolvido separadamente, começando pela Web API, responsável por gerenciar
a comunicação e os dados centrais do sistema. Posteriormente, foram criadas a
interface em .NET MAUI e o aplicativo Android, cada um com funcionalidades
específicas e voltados para públicos distintos. Por fim, todos os componentes foram
integrados e testados para garantir consistência e desempenho. 
 
A escolha das tecnologias foi um ponto-chave para o sucesso do projeto. O
ASP.NET Core foi utilizado para a construção da Web API, oferecendo robustez e
segurança. A interface multiplataforma foi desenvolvida com .NET MAUI, que
simplifica o desenvolvimento ao permitir uma única base de código para diferentes
sistemas operacionais. O aplicativo Android foi projetado com foco em navegação e
7
interação, aproveitando os recursos nativos do sistema para oferecer uma
experiência de alta qualidade aos usuários finais. 
 
A metodologia adotada incluiu a realização de testes unitários, de integração
e de interface para assegurar a confiabilidade do sistema. A documentação
interativa da API foi elaborada com o Swagger, permitindo que desenvolvedores
externos compreendessem e integrassem suas soluções de forma eficiente. Esses
cuidados garantiram um produto final robusto e alinhado às melhores práticas de
desenvolvimento. 
 
Portanto, este trabalho aborda desde a concepção até a validação de um
sistema de streaming de conteúdo multimídia, destacando sua relevância no cenário
atual. A solução proposta é escalável, segura e atende às demandas de criadores e
consumidores, consolidando-se como uma abordagem inovadora e eficaz para o
setor. 
8
2 DESENVOLVIMENTO
2.1 Pré-Projeto
O pré-projeto é uma etapa fundamental no desenvolvimento de software, pois
sem o entendimento completo do problema a ser tratado e um bem elaborado plano
de projeto em mãos, você e sua equipe não saberão onde querem e precisam
chegar. Devmedia (2009).
 
Antes de iniciar o desenvolvimento do sistema de streaming de conteúdo
multimídia, foi realizada uma análise detalhada dos objetivos e requisitos
estabelecidos pela empresa fictícia. O foco principal foi organizar as atividades de
forma estruturada para garantir que cada funcionalidade essencial fosse atendida,
mantendo o alinhamento com as expectativas do projeto. A primeira etapa envolveu
o levantamento das necessidades dos diferentes públicos atendidos pela solução: os
criadores de conteúdo, que utilizariam ferramentas para gerenciar suas playlists e
analisar métricas; e os usuários finais, que consumiriam o conteúdo por meio de
uma interface intuitiva e funcional. 
 
Com base nas demandas levantadas, o projeto foi dividido em três
componentes principais. A Web API, desenvolvida em C# utilizando o ASP.NET
Core, seria responsável por conectar o banco de dados ao restante das aplicações,
garantindo uma integração segura e eficiente entre os módulos. Paralelamente, foi
planejado o desenvolvimento de um protótipo em .NET MAUI voltado para criadores
de conteúdo, oferecendo funcionalidades como upload de arquivos e gestão de
playlists. Por último, foi projetado o aplicativo Android, que atenderia os usuários
finais com navegação por playlists, reprodução de conteúdos multimídia e recursos
de interação social. 
 
Para assegurar uma execução eficiente, as etapas foram organizadas de
forma sequencial e estratégica. Primeiramente, foi realizada a modelagem do banco
de dados, com a definição das entidades principais e suas relações. Diagramas
Entidade-Relacionamento e de Classes foram utilizados para documentar e alinhar a
estrutura com os objetivos do projeto. Em seguida, os ambientes de
desenvolvimento foram configurados para cada tecnologia envolvida, garantindo que
as ferramentas essenciais estivessem prontas para uso. Essa fase incluiu a
instalação de bibliotecas como Entity Framework, para manipulação de dados, e
Swagger, para a documentação interativa da API. 
9
2.2 Implementação da Web API em C#
A Web API foi desenvolvida utilizando ASP.NET Core, uma plataforma robusta
para criação de serviços web que seguem o padrão RESTful. Esse padrão permite
que as operações de CRUD (Create, Read, Update, Delete) sejam realizadas de
forma clara, estruturada e acessível para diferentes tipos de aplicações, incluindo
front-ends e aplicativos móveis. 
 
ASP.NET Core é uma das principais tecnologias para o desenvolvimento de
APIs modernas devido às suas características, como: 
Performance: É otimizado para alta performance, garantindo rapidez nas
requisições. 
Multiplataforma: Funciona em Windows, Linux e macOS.
Flexibilidade: Oferece suporte para injeção de dependência e fácil
configuração de middlewares.
Integração com Entity FrameworkCore: Facilita o acesso ao banco de
dados usando um modelo baseado em objetos. 
2.2.1 Configuração Inicial 
O primeiro passo foi configurar o ambiente de desenvolvimento para suportar
a criação da API. Isso incluiu a adição de pacotes essenciais no arquivo .csproj,
responsáveis por funcionalidades críticas do projeto: 
 
Microsoft.EntityFrameworkCore: Permite interagir com o banco de dados
utilizando o Entity Framework Core, que simplifica o acesso aos dados por
meio de ORM (Object-Relational Mapping). Essa abordagem elimina a
necessidade de escrever comandos SQL diretamente.
Microsoft.EntityFrameworkCore.SqlServer: Esse pacote fornece suporte
para bancos de dados SQL Server, permitindo que o Entity Framework Core
gere consultas específicas para este sistema gerenciador de banco de dados.
Microsoft.AspNetCore.Authentication.JwtBearer: Utilizado para
configurar a autenticação com base em JSON Web Tokens (JWT), que é uma
das formas mais seguras e modernas de autenticar usuários em APIs
RESTful. O JWT permite que informações do usuário sejam verificadas sem
consultar o banco de dados em cada requisição.
Swashbuckle.AspNetCore: Ferramenta para integrar a documentação
Swagger na API. O Swagger fornece uma interface visual para explorar os
endpoints, testar requisições e entender o funcionamento geral da API.
10
Código 1 — Arquivo de Configuração 
Fonte: O autor (2024).
2.2.2 Estrutura do Banco de Dados 
A estrutura do banco de dados foi projetada com base nas entidades
principais do sistema de streaming de conteúdo multimídia. Cada tabela foi
cuidadosamente modelada para representar os dados essenciais e suas relações,
garantindo um acesso eficiente e organizado às informações. 
2.2.2.1 Relacionamentos e Normalização
O banco de dados foi projetado com base no modelo de terceira forma normal
(3FN) para evitar redundâncias e inconsistências. As principais relações foram
estabelecidas conforme o diagrama Entidade-Relacionamento: 
 
Relacionamento entre Usuarios e Playlists: Um para muitos: um usuário
pode ter várias playlists.
Relacionamento entre Playlists e Conteudos: Muitos para muitos:
intermediado pela tabela ItemPlaylist.
Relacionamento entre Criadores e Conteudos: Um para muitos: um
11
criador pode ser responsável por vários conteúdos.
Código 2 — Classe de Contexto para o Entity Framework Core 
Fonte: O autor (2024).
2.2.3 Endpoints Implementados 
A API foi projetada para oferecer endpoints RESTful que possibilitam o
gerenciamento das principais entidades do sistema, garantindo interações
consistentes e eficientes com o banco de dados. Essa estrutura permite que a API
seja consumida por diferentes interfaces, como aplicativos móveis e sistemas web,
promovendo integração e facilidade de uso. 
 
O endpoint /api/usuarios gerencia os usuários cadastrados na plataforma.
Ele possibilita operações como criação, consulta, atualização e exclusão de
registros. A funcionalidade de consulta geral retorna uma lista de usuários,
facilitando o monitoramento e a administração. Já a consulta individual fornece
12
informações detalhadas sobre um usuário específico. Na criação de um novo
registro, os dados básicos, como nome e email, são enviados, e o sistema atribui
automaticamente um identificador único. Além disso, a atualização permite modificar
dados previamente cadastrados, enquanto a exclusão elimina registros
desnecessários ou inativos. 
 
O endpoint /api/playlists permite que os usuários organizem coleções
personalizadas de conteúdos. Ele viabiliza a criação de novas playlists, a consulta
detalhada de seus conteúdos associados, a edição de informações como nome, e a
exclusão de playlists que não são mais necessárias. Essa funcionalidade é essencial
para que os criadores mantenham seus materiais organizados e acessíveis. O
gerenciamento das playlists facilita a interação entre os criadores e os
consumidores, promovendo uma experiência mais fluida e intuitiva para ambas as
partes. 
 
O endpoint /api/conteudos é responsável pelo controle dos conteúdos
multimídia armazenados na plataforma. Por meio dele, os criadores podem adicionar
novos materiais, definir informações como título e tipo, e realizar alterações ou
exclusões quando necessário. O vínculo entre os conteúdos e as playlists é
gerenciado automaticamente pelo sistema, permitindo que um mesmo material seja
compartilhado em diferentes coleções. Assim, o gerenciamento dos conteúdos se
torna mais flexível e eficiente. 
 
Por último, o endpoint /api/autenticacao garante a segurança do sistema ao
implementar um mecanismo de autenticação baseado em JSON Web Tokens (JWT).
Ele valida as credenciais dos usuários e retorna um token que deve ser usado em
requisições subsequentes para acessar recursos protegidos. O token contém
informações essenciais sobre o usuário e suas permissões, permitindo um controle
preciso do acesso aos serviços disponibilizados pela API. Essa abordagem
simplifica a autenticação, reduzindo a necessidade de consultas contínuas ao banco
de dados durante o uso do sistema. 
 
Os endpoints foram documentados com o uso do Swagger, que disponibiliza
uma interface clara para explorar as rotas, parâmetros e respostas esperadas. Essa
documentação facilita o trabalho de integração com outros sistemas e ajuda os
desenvolvedores a compreenderem as funcionalidades da API de forma objetiva e
prática. 
13
Código 3 — Controller para Usuários 
Fonte: O autor (2024).
14
2.2.4 Segurança e Autenticação 
A autenticação foi implementada utilizando JWT (JSON Web Token), um
padrão aberto que permite a transmissão segura de informações entre partes como
um objeto JSON. O JWT é formado por três partes principais: o header, que
especifica o tipo de token e o algoritmo de assinatura; o payload, que contém as
informações do usuário, como identificador e permissões; e a signature, que
autentica o token e assegura a integridade dos dados, garantindo que não foram
alterados durante a transmissão. Segundo a Alura, a assinatura é gerada utilizando
a combinação do header e do payload com uma chave secreta, tornando o JWT
seguro para validar identidades sem consultas constantes ao banco de dados. Alura
(2022).
 
Ao autenticar-se, o usuário recebe um token JWT que deve ser incluído no
cabeçalho das requisições subsequentes à API. Esse token é então verificado pelo
servidor, que valida sua assinatura e, consequentemente, a identidade do usuário e
suas permissões. Essa abordagem otimiza o desempenho da API e melhora a
experiência geral, ao mesmo tempo que mantém altos níveis de segurança. 
15
Código 4 — Serviço para Geração de Token 
Fonte: O autor (2024).
2.2.5 Documentação com Swagger 
A documentação da API foi elaborada utilizando o Swagger, uma ferramenta
que facilita a criação de documentação interativa para APIs RESTful. O Swagger
permite que desenvolvedores visualizem e interajam com os endpoints disponíveis,
compreendendo suas funcionalidades e parâmetros de forma clara e intuitiva. Além
16
disso, o Swagger gera automaticamente uma interface web que exibe a
documentação da API, possibilitando testes diretos dos endpoints sem a
necessidade de ferramentas externas. Essa abordagem não apenas melhora a
compreensão da API, mas também agiliza o processo de desenvolvimento e
integração. (Swagger).
Código 5 — Configuração do Swagger 
Fonte: O autor (2024).
2.3 Interface Gráfica
A interface gráfica voltada para criadores de conteúdo foi desenvolvida
utilizando .NET MAUI (Multi-platform App UI), uma estrutura moderna da Microsoft
para criação de aplicativos multiplataforma. Com o .NET MAUI, é possível escrever
uma única base de código C# e XAML que se adapta a diferentes sistemas
17
operacionais, como Windows, macOS, Android e iOS, reduzindo o esforço de
desenvolvimento e manutenção. Essa tecnologia permite a criação de interfaces
gráficas responsivas, priorizando a experiência do usuário por meio de componentes
visuais otimizados para cada plataforma. 
2.3.1 Estrutura do Projeto 
A aplicação foi organizadaem três camadas principais: 
Views: Contém as telas e componentes visuais. 
ViewModels: Gerencia a lógica de interface e conecta-se com a API. 
Models: Representa as entidades, como Playlist e Conteudo.
2.3.2 Funcionalidades Implementadas 
Upload de Conteúdo: Tela para adicionar novos arquivos e associá-los a
uma playlist.
Gestão de Playlists: Exibição, criação, edição e exclusão de playlists. 
Relatórios: Simulação de gráficos com métricas, como visualizações e
interações.
Código 6 — Model 
Fonte: O autor (2024).
18
Código 7 — ViewModel para Gerenciar Playlists 
Fonte: O autor (2024).
 
2.3.3 Tela Inicial 
A tela inicial apresenta um menu com as opções principais: Criar nova playlist,
Gerenciar conteúdo e Analisar métricas, organizadas de forma intuitiva para facilitar
a navegação do criador de conteúdo. O design foi pensado para destacar as
funcionalidades mais relevantes, utilizando os princípios de usabilidade e
acessibilidade oferecidos pelo .NET MAUI. Cada opção é representada por botões
interativos que, ao serem acionados, redirecionam o usuário para telas específicas,
otimizando o fluxo de trabalho e promovendo uma experiência de uso fluida e
19
responsiva. 
Código 8 — XAML da Tela Inicial 
Fonte: O autor (2024).
2.3.4 Simulação de Upload de Conteúdo 
Uma das funcionalidades chave é o upload de arquivos, que permite ao
criador de conteúdo adicionar novos materiais à plataforma. Essa funcionalidade foi
projetada para interagir diretamente com a API, garantindo que os arquivos sejam
enviados de forma segura e eficiente. O processo utiliza requisições HTTP com
suporte a multipart/form-data, permitindo o envio de metadados juntamente com o
arquivo. 
20
Código 9 — Lógica de Upload 
Fonte: O autor (2024).
2.4 Aplicativo Android
O aplicativo Android foi projetado para oferecer aos usuários finais uma
experiência otimizada no consumo de conteúdo multimídia, com funcionalidades que
atendem às suas principais necessidades. A navegação por playlists permite que os
usuários explorem coleções organizadas de conteúdos, com interfaces que
apresentam listas bem estruturadas e intuitivas. Cada playlist exibe informações
detalhadas, como título, descrição e a quantidade de itens disponíveis,
proporcionando uma visão clara do material disponível. Essa abordagem facilita a
busca por conteúdo relevante e torna o processo de exploração mais agradável. 
 
Além disso, o aplicativo inclui a reprodução de conteúdo multimídia com
suporte a vídeos, áudios e outros formatos, utilizando componentes nativos do
Android para garantir uma performance fluida e compatibilidade com diversos
dispositivos. A funcionalidade de interação social complementa a experiência,
permitindo que os usuários avaliem playlists e comentem em conteúdos,
promovendo engajamento e a criação de uma comunidade ativa dentro da
plataforma. Essas interações são integradas ao back-end por meio de uma
21
comunicação eficiente com a API, assegurando que as atividades dos usuários
sejam refletidas em tempo real e armazenadas de maneira segura. Com essas
funcionalidades, o aplicativo se torna uma ferramenta robusta e envolvente para o
público final. 
2.4.1 Estrutura do Projeto 
O projeto segue o padrão Model-View-Controller (MVC): 
 
1. Model: É responsável por representar os dados e suas estruturas dentro do
aplicativo. Nesse caso, ela inclui classes que mapeiam as entidades
principais, como playlists, conteúdos e usuários. Essas classes contêm
atributos e métodos necessários para manipular os dados localmente e para
facilitar a troca de informações com a API. Por exemplo, a classe Playlist
pode armazenar o nome da playlist, seu identificador e a lista de conteúdos
associados. Além disso, o Model pode incluir validações básicas, como
verificar se todos os campos obrigatórios foram preenchidos antes de enviar
dados para o servidor.
2. View: É a interface que o usuário interage diretamente. Ela define a
aparência e o comportamento visual do aplicativo, como botões, listas,
campos de texto e players multimídia. As Views são implementadas utilizando
XML para definir layouts, garantindo que a experiência do usuário seja
consistente e responsiva em diferentes dispositivos Android. Essa camada
não contém lógica de negócios diretamente, mas está conectada ao
Controller para exibir os dados recebidos da API e enviar ações realizadas
pelo usuário, como cliques em botões ou a seleção de uma playlist.
3. Controller: É responsável por gerenciar a lógica do aplicativo e a
comunicação com a API. Ela atua como um intermediário entre a View e o
Model, garantindo que as solicitações dos usuários sejam processadas
corretamente e que as respostas da API sejam manipuladas de forma
adequada. Por exemplo, quando um usuário seleciona uma playlist, o
Controller realiza uma requisição à API para buscar os detalhes daquela
playlist, processa a resposta recebida e instrui a View a atualizar os dados
exibidos na tela. Essa separação de responsabilidades permite que o código
seja modular e facilita a adição de novas funcionalidades sem interferir em
outras camadas.
22
2.4.2 Funcionalidades Implementadas
O aplicativo Android foi desenvolvido com um conjunto de funcionalidades
que garantem uma experiência rica e intuitiva para os usuários finais, priorizando a
navegação eficiente, o consumo fluido de conteúdo multimídia e a possibilidade de
interação social dentro da plataforma. 
 
A funcionalidade de Navegação e Pesquisa permite aos usuários explorar
playlists organizadas em categorias intuitivas, facilitando o acesso aos conteúdos de
maior interesse. As playlists são exibidas em uma interface limpa e responsiva, com
informações como título, descrição e número de itens contidos. Além disso, o
aplicativo inclui uma barra de pesquisa que possibilita aos usuários localizar playlists
específicas por palavras-chave, aprimorando a usabilidade e otimizando o tempo
gasto para encontrar o conteúdo desejado. Esse recurso foi projetado para funcionar
de forma rápida e integrada à API, assegurando que os resultados sejam
atualizados em tempo real. 
 
A Reprodução de Conteúdo é realizada por meio de um player de vídeo
totalmente integrado, que suporta formatos populares e oferece controles intuitivos,
como reprodução, pausa, avanço e retrocesso. O design do player foi pensado para
maximizar a experiência do usuário, permitindo a alternância entre o modo de tela
cheia e a visualização embutida. A reprodução é iniciada diretamente a partir da
playlist selecionada, e o progresso do conteúdo é salvo localmente para que o
usuário possa retomar de onde parou em sessões futuras. Além disso, a integração
com a API garante que as métricas de reprodução sejam enviadas ao servidor,
permitindo o registro de visualizações e o monitoramento do desempenho dos
conteúdos. 
 
Por último, a funcionalidade de Comentários e Avaliações possibilita uma
interação social ativa dentro da plataforma. Os usuários podem deixar comentários
sobre conteúdos específicos, compartilhando opiniões e interagindo com outros
membros da comunidade. Além disso, a opção de avaliar playlists com um sistema
de estrelas ou "curtidas" ajuda a destacar os conteúdos mais populares e a orientar
novos usuários na escolha do que consumir. Esses dados são processados pela
API, permitindo que os criadores de conteúdo acompanhem o engajamento de suas
playlists em tempo real. 
23
Código 10 — Classe Playlist 
Fonte: O autor (2024).
24
Código 11 — Listagem de Playlists 
Fonte: O autor (2024).
25
Código 12 — Integração com Player 
Fonte: O autor (2024).
2.5 Testes e Validação
A qualidade do sistema de streaming de conteúdo multimídia foi assegurada
por meio de uma abordagem robusta de testes e validação. Essa etapa do projeto foi
essencial para identificar e corrigir inconsistências, garantindo que todos os
componentes funcionassem de forma integrada e com alta confiabilidade. Diversos
tipos de testes foram realizados, incluindo testes unitários, de integração e de
interface, além dautilização de ferramentas específicas para validação dos
resultados. 
2.5.1 Testes Unitários 
Os testes unitários foram aplicados para validar individualmente os métodos e
funções de cada componente, principalmente na Web API. Esses testes focaram na
verificação de comportamentos esperados, como a criação, consulta, edição e
exclusão de registros no banco de dados. Por exemplo, para a classe
PlaylistRepository, foram testados cenários como a tentativa de adicionar uma
playlist sem nome e a busca por uma playlist inexistente. 
 
A ferramenta NUnit foi utilizada para executar os testes unitários na Web API.
Ela permitiu a criação de cenários abrangentes, cobrindo desde as operações
básicas até casos de borda, como entrada de dados inválidos. Esses testes
26
garantiram que os métodos implementados respondessem corretamente às
solicitações, evitando falhas durante a execução. 
2.5.2 Testes de Integração 
Os testes de integração foram realizados para verificar a comunicação entre
os diferentes módulos do sistema. A Web API foi testada em conjunto com o
protótipo em .NET MAUI e o aplicativo Android para validar se os dados eram
transmitidos corretamente e em tempo real. 
 
Um exemplo prático foi o teste de integração do upload de arquivos no .NET
MAUI, onde foi verificado se os metadados e os arquivos eram corretamente
enviados para a API e armazenados no banco de dados. Da mesma forma, o
aplicativo Android foi testado para garantir que as playlists criadas na interface para
criadores de conteúdo aparecessem corretamente para os usuários finais.
Ferramentas como Postman e simuladores do Android Studio foram utilizadas para
simular requisições e avaliar respostas em diferentes condições. 
2.5.3 Testes de Interface
Os testes de interface foram realizados para validar a usabilidade e a
experiência do usuário em ambos os aplicativos desenvolvidos. Para o protótipo em
.NET MAUI, os testes garantiram que os botões, formulários e relatórios fossem
responsivos e acessíveis em dispositivos de diferentes tamanhos. Já no aplicativo
Android, o foco esteve na navegação por playlists, reprodução de conteúdos
multimídia e funcionalidades de interação social. 
 
Esses testes incluíram: 
Teste de Navegação: Avaliação da fluidez entre telas e tempos de
resposta. 
Teste de Responsividade: Garantia de que o design se adaptava
adequadamente a diferentes resoluções. 
Teste de Interação: Verificação de cliques, preenchimento de formulários
e exibição de feedback visual para ações realizadas. 
 
2.5.4 Ferramentas de Teste
As ferramentas utilizadas ao longo do processo de validação foram essenciais
27
para assegurar a confiabilidade do sistema. Entre elas: 
Postman: Utilizado para testar e automatizar requisições HTTP aos
endpoints da API. 
Simuladores Android Studio: Empregados para avaliar a performance e
usabilidade do aplicativo Android em diferentes dispositivos e versões do
sistema operacional. 
Swagger: Permitindo a execução e documentação interativa dos
endpoints, auxiliando no teste de funcionalidade da Web API. 
 
2.5.5 Relatório de Resultados
Os resultados dos testes confirmaram a funcionalidade e a estabilidade do
sistema. Entre os destaques: 
Cobertura de Código: Nos testes unitários, foi alcançada uma cobertura
de 85% nas operações principais da Web API. 
Desempenho da API: Respostas dentro de 200ms para consultas simples
e até 500ms para operações mais complexas, como upload de arquivos. 
Erros Detectados e Corrigidos: Identificação de inconsistências no envio
de metadados durante o upload, corrigidas antes da integração final. 
28
3 CONCLUSÃO
O desenvolvimento deste sistema de streaming de conteúdo multimídia
abordou a criação de uma solução integrada composta por uma Web API, um
protótipo em .NET MAUI e um aplicativo Android, demonstrando a viabilidade de
construir uma plataforma que atende tanto criadores quanto consumidores de
conteúdo. O trabalho começou com a identificação do problema, que envolvia a
necessidade de ferramentas eficientes para gerenciar conteúdos e playlists, além de
interfaces intuitivas que proporcionassem uma experiência positiva aos usuários
finais. A importância desse estudo ficou evidente ao considerar o crescimento
exponencial do consumo de conteúdos digitais e a necessidade de soluções
tecnológicas robustas nesse setor. 
 
Cada módulo do projeto desempenhou um papel crucial na resolução do
problema. A Web API foi implementada para centralizar a comunicação e o
gerenciamento de dados, assegurando desempenho e segurança no processamento
de informações. O protótipo em .NET MAUI demonstrou como é possível
desenvolver uma interface multiplataforma eficiente, que atenda às necessidades de
criadores de conteúdo. Já o aplicativo Android destacou-se ao oferecer navegação
intuitiva, reprodução multimídia de alta qualidade e funcionalidades de interação
social, estabelecendo um elo direto entre consumidores e a plataforma. 
 
A metodologia adotada foi fundamental para o sucesso do projeto. Desde o
planejamento até a execução, foram aplicadas práticas de desenvolvimento que
incluíram o levantamento de requisitos, modelagem de banco de dados, testes
rigorosos e integração dos componentes. O uso de ferramentas como Swagger para
documentação e Postman para validação dos endpoints foi essencial para garantir a
confiabilidade do sistema. Os testes realizados, tanto unitários quanto de integração,
permitiram identificar e corrigir inconsistências, assegurando que o sistema entregue
fosse funcional e robusto. 
 
O trabalho responde diretamente ao problema proposto, ao demonstrar que é
possível criar uma plataforma completa e integrada, atendendo aos requisitos
funcionais e técnicos definidos no início do projeto. A solução desenvolvida oferece
escalabilidade e flexibilidade, estando preparada para se adaptar a futuras
demandas do mercado e de seus usuários. A plataforma também se mostrou
eficiente na integração de diferentes tecnologias, consolidando-se como uma
abordagem moderna e alinhada às tendências do setor. 
29
Como proposta de continuidade, sugere-se o aprofundamento em
funcionalidades adicionais, como a implementação de inteligência artificial para
recomendação de conteúdos e a integração com plataformas externas, como redes
sociais e serviços de nuvem. Além disso, a aplicação de métricas mais avançadas
de análise de dados poderia enriquecer a experiência tanto para criadores quanto
para consumidores. Dessa forma, o sistema pode evoluir para atender a um público
ainda mais amplo e diversificado, reforçando sua relevância no cenário digital atual. 
30
REFERÊNCIAS
ALURA. O que é JSON Web Tokens?. alura.com.br. 2022. 1 p. Disponível em:
https://www.alura.com.br/artigos/o-que-e-json-web-tokens. Acesso em: 21 nov. 2024.
DEVMEDIA. Gestão de Projetos de Software. 2009. 1 p. Disponível em:
https://www.devmedia.com.br/gestao-de-projetos-de-software/9143. Acesso em: 21
nov. 2024.
SWAGGER. Swagger Documentation. swagger.io. Disponível em:
https://swagger.io/docs/?. Acesso em: 25 nov. 2024.
31