terça-feira, 17 de junho de 2025

UFCD 5423 - Criando Login Page

 


1. Criar um projeto com nome loginpage, API 33, Kotlin


2. Layout: activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/mainLayout"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="24dp"
android:orientation="vertical"
android:gravity="center"
android:background="#F5F5F5">

<EditText
android:id="@+id/username"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Username"
android:inputType="textPersonName"
android:layout_marginBottom="12dp" />

<EditText
android:id="@+id/password"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Password"
android:inputType="textPassword"
android:layout_marginBottom="20dp" />

<Button
android:id="@+id/loginButton"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Login" />
</LinearLayout>

3. MainActivity.kt

package com.emerson.loginpage

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import com.emerson.loginpage.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {

private lateinit var binding: ActivityMainBinding

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)

binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)

binding.loginButton.setOnClickListener {
val user = binding.username.text.toString()
val pass = binding.password.text.toString()

if (user == "user" && pass == "1234") {
Toast.makeText(this, "Login Successful!", Toast.LENGTH_SHORT).show()
} else {
Toast.makeText(this, "Login Failed!", Toast.LENGTH_SHORT).show()
}
}
}
}

4. build.gradle.kts(app)

plugins {
alias(libs.plugins.android.application)
alias(libs.plugins.kotlin.android)
}

android {
namespace = "com.emerson.loginpage"
compileSdk = 35

defaultConfig {
applicationId = "com.emerson.loginpage"
minSdk = 33
targetSdk = 35
versionCode = 1
versionName = "1.0"

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

buildFeatures {
viewBinding = true // Aqui você ativa o ViewBinding corretamente
}

buildTypes {
release {
isMinifyEnabled = false
proguardFiles(
getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro"
)
}
}

compileOptions {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}

kotlinOptions {
jvmTarget = "11"
}
}

dependencies {
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.appcompat)
implementation(libs.material)
implementation(libs.androidx.activity)
implementation(libs.androidx.constraintlayout)

testImplementation(libs.junit)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.androidx.espresso.core)
}

5. Clique no botão Run App



domingo, 8 de junho de 2025

UFCD 5423 - Navegação básica em aplicativos Android Nativo com XML

 





Navegação básica em aplicativos Android Nativo com XML

Aqui temos o código fonte de um tutorial gravado em vídeo disponibilizado gratuitamente no youtube: https://www.youtube.com/watch?v=xqEmM2u15JQ&list=PLkwgaJSkQE70-JUYbS0qfT56P35aaHDfp

Cópia de Sem nome

Nesse repositório está disponível o código do tutorial de 3 etapas, sobre navegação, passagem de parâmetros e de objetos entre telas usando o Intent em um aplicativo Android Nativo com XML.

Código básico para navegação entre Telas:

Crie uma intent.

Essa intent precisa de dois parâmetros:

  • O contexto e a Activity de destino no caso o contexto dentro de uma Activity é o "this".
  • E a Activity de destino, que deve ser colocada com o nome seguido de ::class.java, como no exemplo "HomeActivity::class.java"

Por fim, use o startActivity, passando a intent criada.

A ação de navegação pode ser feita por se chamar esse trecho de código no clique de um botão, por exemplo.

val intent = Intent(this, HomeActivity::class.java)
startActivity(intent)

Link do tutorial: https://www.youtube.com/watch?v=xqEmM2u15JQ&t=3s

Código básico para passar parâmetros entre telas:

Com uma Intent já criada, adicione o parâmetro que deseja enviar a segunda tela usando um putExtra: O putExtra funciona com o uso de chave/valor. A chave é um valor em String que vai identificar o parâmetro enviado na tela seguinte. O valor é o parâmetro em si, que pode ser por exemplo uma String, um Boolean, um Float e etc…

val name = "Diego"

val intent = Intent(this, HomeActivity::class.java)
intent.putExtra("name", name)
startActivity(intent)

Na tela de destino use a Intent para receber o valor que foi enviado: Use intent.get o tipo de dado enviado no parâmetro, por exemplo intent.getStringExtra para String, intent.getIntExtra para Inteiro, intent.getBooleanExtra para boleano e etc… em alguns casos é necessário definir um valor padrão como por exemplo intent.getIntExtra("age", 10) No get[TIPO]Extra, você usa a mesma chave usada para enviar o parâmetro, como por exemplo intent.getStringExtra("name")

val name = intent.getStringExtra("name")

É possível enviar e receber vários parâmetros na mesma Intent, para isso basta acrescentar novos putExtra a sua intent. Exemplo:

val name = "Diego"
val age = 100
val isSubscribe = true
val score = 100000.00

val intent = Intent(this, HomeActivity::class.java)
intent.putExtra("name", name)
intent.putExtra("age", age)
intent.putExtra("isSubscribe", isSubscribe)
intent.putExtra("score", score)
startActivity(intent)

Link do tutorial: https://www.youtube.com/watch?v=gEvjCxe3ZBc

Código básico para passar objetos entre telas:

Com uma Intent já criada, adicione o objeto que deseja enviar a segunda tela usando um putExtra: Para que o objeto seja enviado via putextra ele precisa ser serializável

data class User(
    //Atributos do objeto
) : Serializable //Objeto serializável

O objeto sendo Serializable o envio é feito da mesma forma que o envio de um parâmetro qualquer.

val user = User(...atributos do usuário…)

val intent = Intent(this, HomeActivity::class.java)
intent.putExtra("user", user)
startActivity(intent)

Na tela de destino use a Intent para receber o objeto que foi enviado: É necessário fazer um Cast pro objeto, já que o intet.getSerializableExtra é genérico. Por exemplo intent.getSerializableExtra("user") as User

val user = intent.getSerializableExtra("user") as User

Link do tutorial: https://www.youtube.com/watch?v=OWGOlmVZeyk

Observações importantes

Essa é a forma básica de navegar, passar parâmetros e objetos entre telas em aplicativos Android Nativo XML. Porém não necessariamente é a melhor em especial se tratando de objetos já que getSerializableExtra está deprecated.

De qualquer forma é importante conhecer e entender como trabalhar com Intent, em especial em aplicativos com XML (que ainda são maioria na data que escrevo essa documentação).

Trabalhando com apps Android XML por exemplo existe a possibilidade de trabalhar com o Jetpack Navigation, para navegação, passagem de parâmetros e etc…

Para aplicativos novos, é recomendável o uso do Jetpack Compose.

Projeto com código para navegação com Jetpack Compose: https://github.com/DiegoLinks/compose-navigation

Vídeos tutoriais para navegação com Jetpack Compose: https://www.youtube.com/watch?v=MWtzPxftX_s&list=PLkwgaJSkQE72uFrk_wVlvr5JUnHfv2IUx

sábado, 7 de junho de 2025

UFCD 5423 - Criação de um Bot no Whatsapp Web

 


Para criar chabot pelo WhatsApp segue os seguintes passo a passo:


1- Instalar o Servidor NodeJS


2- Criar a pasta do projeto ex: “whatsbot” pelo linha do comando no

PowerShell “mkdir whatsbot”.


3- Acessar o a pasta do projecto “pelo linha do comando no PowerShell “cd

whatsbot”, ou abrir a pasta com vscode.


4- Instalar das dependências do projecto, com o seguintes comandos: “npm

init -y” para package.json e veficar no package.json contem o "scripts": {

"start": "node index.js" }, para que depois da criação do index.js no

terminar executar com o comando “npm start”, e para package-lock.json o

comando “npm install”.



5- Instalar a dependência WhatsApp com o seguinte comando “npm i

whatsapp-web.js”

6- Instalar a dependência qrcode com o seguinte comando “npm install

qrcode-terminal”.

7- Criação do ficheiro principal do projeto index.js como os metedos

necessário para execução do projeto: “





8- no terminar executar o comando ”npm start “ para inicializar o programa

que por sua vez apresentar o qrcode para associação ao nosso Wathsap, uma vez

associada qualquer pessoa com meu contacto ao enviar mensagem com o texto

“!teste” o meu chat Bot responde com mensagem automática “aulas”. A partir

desta base podemos desenvolver um Chat Bot personalizado com perguntas e

respostas

Qrcode do meu projecto: 




Enfim, vamos testar na aplicação whatsapp e o resultado será esse a seguir:











terça-feira, 3 de junho de 2025

UFCD 10793 - Widget em Python

 


Código para criar um Widget em Python

Criação de um GUI em Python utilizando o Tk, para criar um Widget que aceita valores de resistência (R), em ohm e corrente (I), em ampere, para calcular a tensão (U), em volt, utilizando a lei de Ohm.

from tkinter import *
from tkinter import ttk

def calculate(*args):
    try:
        valor_R = float(R.get())
        valor_I = float(I.get())
        tensao.set(float(valor_R * valor_I))
    except Exception as erro:
        print(erro)

root = Tk()
root.title("Tensão na resistência")

mainframe = ttk.Frame(root, padding="3 3 12 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
root.columnconfigure(0, weight=1)
root.rowconfigure(0, weight=1)

R = StringVar()
I = StringVar()
R_entry = ttk.Entry(mainframe, width=7, textvariable=R)
R_entry.grid(column=2, row=1, sticky=(W, E))
I_entry = ttk.Entry(mainframe, width=7, textvariable=I)
I_entry.grid(column=12, row=1, sticky=(W, E))

tensao = StringVar()
ttk.Label(mainframe, textvariable=tensao).grid(column=3, row=2, sticky=(W, E))

ttk.Button(mainframe, text="Calcular", command=calculate).grid(column=12, row=2, sticky=W)

ttk.Label(mainframe, text="Resistência:").grid(column=1, row=1, sticky=W)
ttk.Label(mainframe, text="ohm").grid(column=3, row=1, sticky=W)

ttk.Label(mainframe, text="Corrente:").grid(column=11, row=1, sticky=W)
ttk.Label(mainframe, text="ampere").grid(column=13, row=1, sticky=W)

ttk.Label(mainframe, text="A tensão vale:").grid(column=2, row=2, sticky=E)
ttk.Label(mainframe, text="volt").grid(column=10, row=2, sticky=W)

for child in mainframe.winfo_children():
    child.grid_configure(padx=5, pady=5)

R_entry.focus()
root.bind("<Return>", calculate)

root.mainloop()






UFCD 10797 - Views no SQL – Views no MySQL

 




Views no SQL – Views no MySQL

A ideia de uma view é armazenar as informações de uma consulta em SQL. Ou seja, quando utilizamos um filtro ou fazemos qualquer consulta dentro do banco de dados, geramos uma visualização temporária.

Para que essa visualização seja salva e possamos utilizá-la posteriormente, é importante salvar essa consulta dentro de uma view.

Isso é extremamente útil porque nem sempre fazemos consultas simples de apenas selecionar e visualizar uma tabela do banco de dados. Às vezes, as consultas são mais complexas e levam tempo.

Com as views, ao invés de ter que criar a consulta toda vez que for utilizá-la, você só precisa chamar a view que foi criada.

Isso nos possibilita salvar a consulta e depois acessá-la com apenas uma única linha de código, e o melhor: ainda poder trabalhar com ela normalmente se precisar expandir as análises feitas.

Criação de Views no SQL – Como Criar Visualizações no SQL

Antes de começar criando visualizações no SQL, vamos entender o que é uma visualização de fato para que facilite o seu entendimento.

Fazendo uma consulta para visualizar o resultado
Fazendo uma consulta para visualizar o resultado

Aqui nós temos uma consulta com um filtro, só que essa visualização que temos na parte inferior ela é temporária, então assim que nós utilizarmos outra consulta ela vai embora.

A ideia então é armazenar isso para que possamos utilizar posteriormente, por isso é que vamos utilizar as visualizações!

Então as views são uma possibilidade de salvar o resultado dessas consultas, além de permitir que você utilize essa visualização posteriormente.

Tipos de ações para um view
Tipos de ações para um view

Aqui nós vamos ter 3 possibilidades: criação de uma view, alteração de uma view e exclusão de uma view.

Views no SQL
Criando uma view

Agora vamos partir para a criação da view, lembrando que vamos começar com o comando CREATE VIEW e depois o nome dessa view.

Logo abaixo temos as informações que vamos armazenar nessa view, que é o filtro da tabela DimCustomer, mas pegando apenas o tipo igual a Person.

Podemos utilizá-la como se fosse uma tabela mesmo, então podemos manipular, visualizar, utilizar para cálculos…

Views no SQL
Alterando uma view

Para o segundo exemplo temos um código de CREATE com ALTER, utilizando o OR, pois assim se a view não existir ela será criada, e se ela existir vamos apenas alterá-la.

Quando precisar excluir uma view é muito simples, basta utilizar o comando DROP VIEW.

Views no SQL
Excluindo uma view

A ideia da view é facilitar o seu trabalho, assim não terá que ficar reescrevendo todos os comandos que utilizou, ainda mais se for algo mais complexo em uma base de dados maior.

Não é vantagem reescrever tudo sempre que quiser visualizar essas informações ou fazer cálculos.

Outro ponto interessante é a questão da segurança, pois uma view é apenas uma parte da tabela, ou seja, vai ter apenas as informações que foram gravadas nela, não vamos ter acesso a tudo da base de dados a partir da view.

Conclusão

Nessa aula eu te mostrei a diferença entre os objetos dentro de um banco de dados, que são as tabelas e as views.

Além disso te mostrei algumas vantagens das views que podem te ajudar muito nos seus projetos, principalmente para economizar tempo, assim como fazer a criação dessas views no SQL!