Universidad Catolica de Honduras

“Nuestra Señora Reina de la Paz”

Campus San Isidro

MANUAL TÉCNICO

Proyecto: App de Diario Personal

Docente: Ing. Abraham Sikaffy

Clase: Implementación de Sistemas 1701

IIP2024

Facultad: ICC

7/29/2024
La Ceiba, Atlántida.
 App de Diario Personal
MANUAL TÉCNICO

Diario Personal

MANUAL TÉCNICO

1
 App de Diario Personal
MANUAL TÉCNICO

Contenido

Objetivos..............................................................................................................................................................
Objetivos Específicos......................................................................................................................................
Introducción........................................................................................................................................................
Arquitectura del software..................................................................................................................................
Componentes...................................................................................................................................................
Diagramas de Arquitectura.............................................................................................................................
Diagrama Nivel 1......................................................................................................................................
Diagrama de Flujo de Usuario..................................................................................................................
Instalación y Configuración...............................................................................................................................
Requisitos de Sistemas........................................................................................................................................
Instrucciones detalladas de instalación...........................................................................................................
Configuración inicial y ajustes necesarios......................................................................................................
Estructura de Código..........................................................................................................................................
Descripción de módulos y sus dependencias..................................................................................................
Detalles de Implementación...............................................................................................................................
Algoritmos......................................................................................................................................................
Lógica de Negocio..........................................................................................................................................
Detalles sobre bases de datos y esquemas de datos....................................................................................
Estructura de datos..........................................................................................................................................
Diagrama de la base de datos....................................................................................................................
API..................................................................................................................................................................
Servicios Web.................................................................................................................................................
Pruebas y Depuración.........................................................................................................................................
Mantenimiento y Actualizaciones......................................................................................................................
Referencias y Recursos Adicionales..................................................................................................................

2
 App de Diario Personal
MANUAL TÉCNICO

Objetivos
Este documento ha sido elaborado para mostrar cómo se diseñó nuestra aplicación

para crear notas y a la vez dar referencias de cómo interactuar con el programa para su

posible continuación.

Objetivos Específicos

● Dar a conocer el código fuente.

● Expresar los requerimientos del sistema.

● Ofrecer una guía para el funcionamiento de la app

● Documentar los requisitos para su ejecución

3
 App de Diario Personal
MANUAL TÉCNICO

Introducción
Este documento ha sido elaborado para mostrar cómo se diseñó nuestra aplicación

para crear notas y a la vez dar referencias de cómo interactuar con el programa para su

posible continuación. Está dirigido hacia los docentes pertenecientes a la facultad ICC y todo

aquel que tenga conocimiento en ciencias de la computación dentro de las clases

programación móvil I e implementación de sistemas recibidas en el IIP 2024 dentro del

campus San Isidro.

4
 App de Diario Personal
MANUAL TÉCNICO

Arquitectura del software

La app de Diario Personal está diseñada para ofrecer a sus usuarios una plataforma

donde puedan plasmar y crear sus ideas por medio de notas personales. Así mismo que logren

gestionar y editarlas en una interfaz sencilla de fácil comprensión. Su arquitectura busca

garantizar una experiencia fluida.

Componentes

● Front-End

○ Aplicación Móvil: Desarrollada en Android Studio

○ Aplicación Web: N/A

● Back-end

● Base de datos: utiliza SQLite para almacenar las notas localmente

● Servicios de sincronización: N/A

Diagramas de Arquitectura

Diagrama Nivel 0

5
App de Diario Personal
MANUAL TÉCNICO

Diagrama Nivel 1

6
App de Diario Personal
MANUAL TÉCNICO

Diagrama de Flujo de Usuario

7
 App de Diario Personal
MANUAL TÉCNICO

Estructura de Código
● Modulo de Actividad Principal

package com.example.notessqlite

import android.app.DownloadManager.Query

import android.content.Intent

import android.os.Bundle

import android.text.TextUtils

import android.view.Menu

import android.view.MenuItem

import android.widget.Toast

import androidx.activity.enableEdgeToEdge

import androidx.appcompat.app.ActionBarDrawerToggle

import androidx.appcompat.app.AppCompatActivity

import androidx.core.view.GravityCompat

import androidx.core.view.ViewCompat

import androidx.core.view.WindowInsetsCompat

import androidx.drawerlayout.widget.DrawerLayout

import androidx.recyclerview.widget.LinearLayoutManager

import com.example.notessqlite.databinding.ActivityAddNoteBinding

import com.example.notessqlite.databinding.ActivityMainBinding

import com.google.android.material.navigation.NavigationView

class MainActivity : AppCompatActivity(),

NavigationView.OnNavigationItemSelectedListener {

private lateinit var binding: ActivityMainBinding

private lateinit var db: NoteDatabaseHelper //despues de declarar la la

clase NotesAdapter

8
 App de Diario Personal
MANUAL TÉCNICO

private lateinit var notesAdapter: NotesAdapter

private lateinit var notesList: List<Note> // Lista de todas las notas

private lateinit var drawerLayout: DrawerLayout

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

binding = ActivityMainBinding.inflate(layoutInflater)

enableEdgeToEdge()

setContentView(binding.root)

//funcinalidad del menu

drawerLayout = binding.drawerLayout

val navView: NavigationView = binding.navView

navView.setNavigationItemSelectedListener(this)

val toggle = ActionBarDrawerToggle(

this, drawerLayout, binding.toolbar,

R.string.navigation_drawer_open, R.string.navigation_drawer_close)

drawerLayout.addDrawerListener(toggle)

toggle.syncState()

db = NoteDatabaseHelper(this)

// Inicializar la lista de notas y el adaptador

notesList = db.getAllNotes()

notesAdapter = NotesAdapter(db.getAllNotes(), this)

// Configurar el RecyclerView

9
 App de Diario Personal
MANUAL TÉCNICO

binding.notesRecyclerView.layoutManager =

LinearLayoutManager(this) //define cómo se mostrarán los

elementos en el RecyclerView.

binding.notesRecyclerView.adapter = notesAdapter

// Listener para el botón de agregar nota

binding.addButton.setOnClickListener {

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

startActivity(intent)

// Configuración del botón de búsqueda

binding.searchButton.setOnClickListener {

val query = binding.searchEditText.text.toString().trim()

if (!TextUtils.isEmpty(query)) {

searchNotes(query)

} else {

Toast.makeText(

this,

"Por favor, ingresa un término de búsqueda",

Toast.LENGTH_SHORT

).show()

10
 App de Diario Personal
MANUAL TÉCNICO

override fun onResume() {

super.onResume()

notesList = db.getAllNotes()

notesAdapter.refreshData(db.getAllNotes())

// Método para realizar la búsqueda de notas

private fun searchNotes(query: String) {

val filteredNotes = filterNotesByQuery(notesList, query)

notesAdapter.refreshData(filteredNotes)

// Método para filtrar las notas basado en el query

private fun filterNotesByQuery(Note: List<Note>, query: String):

List<Note> {

val filteredNotes = mutableListOf<Note>()

for (note in Note) {

if (note.title.contains(query, ignoreCase = true) ||

note.content.contains(

query,

ignoreCase = true

) {

filteredNotes.add(note)

return filteredNotes

11
 App de Diario Personal
MANUAL TÉCNICO

//Funcinalidad menu lateral

override fun onBackPressed() {

if (drawerLayout.isDrawerOpen(GravityCompat.START)) {

drawerLayout.closeDrawer(GravityCompat.START)

} else {

super.onBackPressed()

override fun onNavigationItemSelected(item: MenuItem): Boolean{

when (item.itemId){

R.id.nav_item_one -> {

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

startActivity(intent)

R.id.nav_item_three -> {

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

startActivity(intent)

drawerLayout.closeDrawer(GravityCompat.START)

return true

Agregar Nota

package com.example.notessqlite

12
 App de Diario Personal
MANUAL TÉCNICO

import android.content.Intent

import android.os.Bundle

import android.widget.ImageView

import android.widget.Toast

import androidx.activity.enableEdgeToEdge

import androidx.appcompat.app.AppCompatActivity

import androidx.core.view.ViewCompat

import androidx.core.view.WindowInsetsCompat

import com.example.notessqlite.databinding.ActivityAddNoteBinding

class AddNoteActivity : AppCompatActivity() {

//View Binding se utiliza para evitar el uso de findViewById

// para cada vista. En su lugar, se crea una clase de enlace que

contiene

// referencias directas a todas las vistas.

private lateinit var binding: ActivityAddNoteBinding

private lateinit var db:NoteDatabaseHelper //declaracion de base de

datos

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

binding = ActivityAddNoteBinding.inflate(layoutInflater)

enableEdgeToEdge()

setContentView(binding.root)

binding.returnButton.setOnClickListener {

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

startActivity(intent)

13
 App de Diario Personal
MANUAL TÉCNICO

//inicializacion de la variable db

db=NoteDatabaseHelper(this) //se crea una nueva instancia

binding.saveButton.setOnClickListener{

val title = binding.titleEditText.text.toString() //son los

inputs

val content = binding.contentEditText.text.toString()

val note = Note(0, title, content) //los inputs anteriores se

guardan en esta variable, que es como base de datos

db.insertNote(note) //insertNote es uba funcion se creo antes en

el NoteDatabaseHelper, se envia la varable note

finish() //pausa la actividad que lo regresa al anterior,

tambien cierra la actividad

Toast.makeText(this, "Nota Guardada Correctamente",

Toast.LENGTH_SHORT).show() //mensaje

Adaptador para el uso del “Recycler View”

package com.example.notessqlite

import android.annotation.SuppressLint

import android.content.Context

import android.content.Intent

14
 App de Diario Personal
MANUAL TÉCNICO

import android.view.LayoutInflater

import android.view.View

import android.view.ViewGroup

import android.widget.ImageView

import android.widget.TextView

import android.widget.Toast

import androidx.recyclerview.widget.RecyclerView

class NotesAdapter (private var notes: List<Note>, context: Context) :

RecyclerView.Adapter<NotesAdapter.NoteViewHolder>() {

private val db: NoteDatabaseHelper = NoteDatabaseHelper(context)

class NoteViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView)

val titleTextView: TextView =

itemView.findViewById(R.id.titleTextView)

val contentTextView: TextView =

itemView.findViewById(R.id.contentTextView)

val Updatebutton: ImageView =

itemView.findViewById(R.id.updateButton)

val deleteButton: ImageView =

itemView.findViewById(R.id.deleteButton)

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int):

NoteViewHolder {

val view =

LayoutInflater.from(parent.context).inflate(R.layout.note_item, parent,

false)

15
 App de Diario Personal
MANUAL TÉCNICO

return NoteViewHolder(view)

//Devuelve el número total de elementos en la lista notes.

override fun getItemCount(): Int = notes.size

// este metodo vincula los datos a las vistas del ViewHolder en la

posición especificada.

override fun onBindViewHolder(holder: NoteViewHolder, position: Int) {

val note = notes[position]

holder.titleTextView.text = note.title

holder.contentTextView.text = note.content

holder.Updatebutton.setOnClickListener{

val intent = Intent(holder.itemView.context,

UpdateNoteActivity::class.java).apply{

putExtra("note_id", note.id)

holder.itemView.context.startActivity(intent)

holder.deleteButton.setOnClickListener{

db.deleteNote(note.id)

refreshData(db.getAllNotes())

Toast.makeText(holder.itemView.context, "Nota Eliminada",

Toast.LENGTH_SHORT).show()

16
 App de Diario Personal
MANUAL TÉCNICO

@SuppressLint("NotifyDataSetChanged")

fun refreshData(newNotes: List<Note>){

notes = newNotes //Actualiza la variable notes con la nueva

lista.

notifyDataSetChanged() //Notifica al NotesAdapter que los datos

han cambiado y que debe actualizar la vista.

Database Helper

package com.example.notessqlite

import android.content.ContentValues

import android.content.Context

import android.database.sqlite.SQLiteDatabase

import android.database.sqlite.SQLiteOpenHelper

class NoteDatabaseHelper(context: Context) : SQLiteOpenHelper(context,

DATABASE_NAME, null, DATABASE_VERSION){

companion object{

private const val DATABASE_NAME = "notesapp.db"

private const val DATABASE_VERSION = 1

private const val TABLE_NAME = "allnotes"

private const val COLUMN_ID = "id"

private const val COLUMN_TITLE = "title"

17
 App de Diario Personal
MANUAL TÉCNICO

private const val COLUMN_CONTENT = "content"

override fun onCreate(db: SQLiteDatabase?) {

val createTableQuery = "CREATE TABLE $TABLE_NAME ($COLUMN_ID INTEGER

PRIMARY KEY, $COLUMN_TITLE TEXT, $COLUMN_CONTENT TEXT)"

db?.execSQL(createTableQuery)

override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion:

Int) {

val dropTableQuery = "DROP TABLE IF EXISTS $TABLE_NAME"

db?.execSQL(dropTableQuery)

onCreate(db)

fun insertNote(note: Note){

val db = writableDatabase //se puede modificar

val values = ContentValues().apply{ //contentvalues es una clase que

se usa para guardar valores asociados con las columnas

put(COLUMN_TITLE, note.title)

put(COLUMN_CONTENT, note.content)

db.insert(TABLE_NAME, null, values)

db.close()

//FUNCION DE OBTENER NOTAS que extiende la /lase de la lista notas

18
 App de Diario Personal
MANUAL TÉCNICO

fun getAllNotes(): List<Note>{

val notesList = mutableListOf<Note>() //lista vacia mutable, donde

se captura los datos

val db = readableDatabase // la base de datos no se modificara, solo

sera de lectura

val query = "SELECT * FROM $TABLE_NAME" // consulta

val cursor = db.rawQuery(query, null) //la consulta se guarda en

esta variable

while (cursor.moveToNext()){

//obtencion de datos

val id = cursor.getInt(cursor.getColumnIndexOrThrow(COLUMN_ID))

val title =

cursor.getString(cursor.getColumnIndexOrThrow("title"))

val content =

cursor.getString(cursor.getColumnIndexOrThrow("content"))

val note = Note(id, title, content) //Crea una instancia de Note

con los valores obtenidos.

notesList.add(note) //Añade la instancia de Note a la lista

notesList

cursor.close() //Cierra el cursor para liberar recursos

db.close() //Cierra la base de datos para liberar recursos

return notesList

19
 App de Diario Personal
MANUAL TÉCNICO

fun updateNote(note : Note){

val db = writableDatabase //como se editara, la base de datos debe

estar en modo escritura

val values = ContentValues().apply{ //insercion de datos

put(COLUMN_TITLE, note.title)

put(COLUMN_CONTENT, note.content)

val whereClause = "$COLUMN_ID = ?"

val whereArgs = arrayOf(note.id.toString()) //argumentos

db.update(TABLE_NAME, values, whereClause, whereArgs)

db.close()

fun getNoteById(noteId: Int): Note{

val db = writableDatabase

val query = "SELECT * FROM $TABLE_NAME WHERE $COLUMN_ID = $noteId"

val cursor = db.rawQuery(query, null)

cursor.moveToFirst()

val id = cursor.getInt(cursor.getColumnIndexOrThrow(COLUMN_ID))

val title =

cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_TITLE))

val content =

cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_CONTENT))

cursor.close()

db.close()

return Note(id, title, content)

20
 App de Diario Personal
MANUAL TÉCNICO

fun deleteNote(noteId: Int) {

val db = writableDatabase

val whereClause = "$COLUMN_ID = ?"

val whereArgs = arrayOf(noteId.toString())

db.delete(TABLE_NAME, whereClause, whereArgs)

db.close()

Actividad del Bloqueo

package com.example.notessqlite

import android.content.Intent

import android.os.Bundle

import androidx.activity.enableEdgeToEdge

import androidx.appcompat.app.AppCompatActivity

import androidx.core.view.ViewCompat

import androidx.core.view.WindowInsetsCompat

import com.example.notessqlite.databinding.ActivityConCodigoBinding

import com.example.notessqlite.databinding.ConfirmacionBinding

class BloqueoActivity: AppCompatActivity() {

private lateinit var binding: ActivityConCodigoBinding

21
 App de Diario Personal
MANUAL TÉCNICO

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

enableEdgeToEdge()

setContentView(R.layout.activity_con_codigo)

binding = ActivityConCodigoBinding.inflate(layoutInflater)

setContentView(binding.root)

binding.ingresar.setOnClickListener {

// Navega de regreso a la actividad principal o a otra actividad

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

startActivity(intent)

Interfaz de confirmación

package com.example.notessqlite

import android.content.Intent

import android.os.Bundle

import androidx.appcompat.app.AppCompatActivity

import com.example.notessqlite.databinding.ConfirmacionBinding

class ConfirmacionActivity : AppCompatActivity() {

private lateinit var binding: ConfirmacionBinding

22
 App de Diario Personal
MANUAL TÉCNICO

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

binding = ConfirmacionBinding.inflate(layoutInflater)

setContentView(binding.root)

binding.buttonAceptar.setOnClickListener {

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

startActivity(intent)

binding.cerrar.setOnClickListener {

// Navega de regreso a la actividad principal o a otra actividad

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

startActivity(intent)

Establecer el codigo de bloqueo

package com.example.notessqlite

import android.content.Context

import android.content.Intent

import android.os.Bundle

import androidx.activity.enableEdgeToEdge

23
 App de Diario Personal
MANUAL TÉCNICO

import androidx.appcompat.app.AppCompatActivity

import androidx.core.view.ViewCompat

import androidx.core.view.WindowInsetsCompat

import com.example.notessqlite.databinding.ActivityMainBloqueoBinding

import com.example.notessqlite.databinding.ActivityNosotrosBinding

class Main_Activity_Bloqueo : AppCompatActivity() {

private lateinit var binding: ActivityMainBloqueoBinding

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

enableEdgeToEdge()

setContentView(R.layout.activity_main_bloqueo)

binding = ActivityMainBloqueoBinding.inflate(layoutInflater)

enableEdgeToEdge()

setContentView(binding.root)

binding.returnButton.setOnClickListener {

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

startActivity(intent)

binding.guardar.setOnClickListener {

val primerCodigo = binding.primerCodigo.text.toString()

val segundoCodigo = binding.segundoCodigo.text.toString()

if (primerCodigo == segundoCodigo) {

// Guardar el código en SharedPreferences

24
 App de Diario Personal
MANUAL TÉCNICO

val sharedPreferences = getSharedPreferences("DiarioPrefs",

Context.MODE_PRIVATE)

val editor = sharedPreferences.edit()

editor.putString("codigo_diario", primerCodigo)

editor.apply()

// Navegar a la actividad de Confirmación

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

startActivity(intent)

} else {

// Mostrar un mensaje de error

binding.primerCodigo.error = "Los códigos no coinciden"

binding.segundoCodigo.error = "Los códigos no coinciden"

Menu lateral

package com.example.notessqlite

import android.content.res.Configuration

import android.os.Bundle

import android.view.MenuItem

import android.view.View

import android.widget.EditText

import android.widget.ImageView

import android.widget.Toast

import androidx.appcompat.app.ActionBarDrawerToggle

25
 App de Diario Personal
MANUAL TÉCNICO

import androidx.appcompat.app.AppCompatActivity

import androidx.appcompat.widget.Toolbar

import androidx.core.view.GravityCompat

import androidx.drawerlayout.widget.DrawerLayout

import androidx.recyclerview.widget.RecyclerView

import com.google.android.material.navigation.NavigationView

class MainActivity_Menu : AppCompatActivity(),

NavigationView.OnNavigationItemSelectedListener {

private lateinit var drawer: DrawerLayout

private lateinit var toggle: ActionBarDrawerToggle

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

setContentView(R.layout.activity_main)

val toolbar: Toolbar = findViewById(R.id.toolbar_main)

setSupportActionBar(toolbar)

drawer = findViewById(R.id.drawer_layout)

toggle = ActionBarDrawerToggle(this, drawer, toolbar,

R.string.navegation_drawer_open, R.string.navegation_drawer_close)

drawer.addDrawerListener(toggle)

supportActionBar?.setDisplayHomeAsUpEnabled(true)

supportActionBar?.setHomeButtonEnabled(true)

val navigationView: NavigationView = findViewById(R.id.nav_view)

navigationView.setNavigationItemSelectedListener(this)

26
 App de Diario Personal
MANUAL TÉCNICO

// Set the OnClickListener for the menuButton

val menuButton: ImageView = findViewById(R.id.menuButton)

menuButton.setOnClickListener {

if (drawer.isDrawerOpen(GravityCompat.START)) {

drawer.closeDrawer(GravityCompat.START)

} else {

drawer.openDrawer(GravityCompat.START)

override fun onNavigationItemSelected(item: MenuItem): Boolean {

when (item.itemId) {

R.id.nav_item_one -> Toast.makeText(this, "Bloqueo con código",

Toast.LENGTH_SHORT).show()

R.id.nav_item_two -> Toast.makeText(this, "Exportar",

Toast.LENGTH_SHORT).show()

R.id.nav_item_three -> Toast.makeText(this, "Acerca de",

Toast.LENGTH_SHORT).show()

drawer.closeDrawer(GravityCompat.START)

return true

override fun onPostCreate(savedInstanceState: Bundle?) {

super.onPostCreate(savedInstanceState)

27
 App de Diario Personal
MANUAL TÉCNICO

toggle.syncState()

override fun onConfigurationChanged(newConfig: Configuration) {

super.onConfigurationChanged(newConfig)

toggle.onConfigurationChanged(newConfig)

override fun onOptionsItemSelected(item: MenuItem): Boolean {

if (toggle.onOptionsItemSelected(item)) {

return true

return super.onOptionsItemSelected(item)

Acerca de Nosotros

package com.example.notessqlite

import android.content.Intent

import android.os.Bundle

import androidx.activity.enableEdgeToEdge

import androidx.appcompat.app.AppCompatActivity

import androidx.core.view.ViewCompat

import androidx.core.view.WindowInsetsCompat

import com.example.notessqlite.databinding.ActivityNosotrosBinding

class NosotrosActivity : AppCompatActivity() {

28
 App de Diario Personal
MANUAL TÉCNICO

private lateinit var binding: ActivityNosotrosBinding

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

binding = ActivityNosotrosBinding.inflate(layoutInflater)

enableEdgeToEdge()

setContentView(binding.root)

ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) {

v, insets ->

val systemBars =

insets.getInsets(WindowInsetsCompat.Type.systemBars())

v.setPadding(systemBars.left, systemBars.top, systemBars.right,

systemBars.bottom)

insets

binding.returnButton.setOnClickListener {

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

startActivity(intent)

Actualizar la nota

package com.example.notessqlite

import android.content.Intent

29
 App de Diario Personal
MANUAL TÉCNICO

import android.os.Bundle

import android.os.PersistableBundle

import android.widget.ImageView

import android.widget.Toast

import androidx.activity.enableEdgeToEdge

import androidx.appcompat.app.AppCompatActivity

import androidx.core.view.ViewCompat

import androidx.core.view.WindowInsetsCompat

import com.example.notessqlite.databinding.ActivityAddNoteBinding

import com.example.notessqlite.databinding.ActivityUpdateNoteBinding

class UpdateNoteActivity : AppCompatActivity() {

private lateinit var binding: ActivityUpdateNoteBinding

private lateinit var db: NoteDatabaseHelper

private var noteId: Int = -1 //-1 significa que el valor esta vacia

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

binding = ActivityUpdateNoteBinding.inflate(layoutInflater)

enableEdgeToEdge()

setContentView(binding.root)

db = NoteDatabaseHelper(this)

30
 App de Diario Personal
MANUAL TÉCNICO

noteId = intent.getIntExtra("note_id", -1) //con getIntExtra

recibimos los daos

if(noteId == -1){

finish()

return

binding.returnButton.setOnClickListener {

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

startActivity(intent)

val note = db.getNoteById(noteId)

binding.UpdateTitleEditText.setText(note.title)

binding.UpdateContentEditText.setText(note.content)

binding.updateSaveButton.setOnClickListener{

val newTitle = binding.UpdateTitleEditText.text.toString()

val newContent = binding.UpdateContentEditText.text.toString()

val updatedNote = Note(noteId, newTitle, newContent)

db.updateNote(updatedNote)

finish()

Toast.makeText(this, "Cambios Guardados",

Toast.LENGTH_SHORT).show()

31
 App de Diario Personal
MANUAL TÉCNICO

Descripción de los módulos y sus dependencias.

● Módulo Principal
○ Este módulo muestra las notas ingresadas por usuario, también es enlace para
gestionar notas existentes que se pueden eliminar y modificar, añadir otras
notas y hacia el menú lateral.

○ Dependencia:para que se muestran las notas guardadas dependen del módulo

de agregar nota.

● Módulo de Agregar Nota

○ Dentro de ella, el usuario podrá escribir el título y contenido de la nota. para
luego guardarla.

○ Dependencia: para ingresar a este módulo es desde el módulo principal

● Módulo de Editar Nota

○ En una nota existente, en este módulo se podrá modificar la nota para luego
actualizarlo dentro de la base de datos

○ Dependencia: una vez que la nota se crea en el modulo de agregar notas y esta
se refleje en módulo principal se podrá ingresar al módulo de editar notas

● Módulo de Menu lateral

○ Tiene la funcionalidad de desplegar otras opciones dentro de la app.

● Módulo de Bloqueo Con Código

○ Tiene la funcionalidad de establecer un código de seguridad para proteger las
notas.

○ Dependencia: para llegar a este módulo es necesario el módulo de menú

lateral.

● Módulo Acerca de Nosotros

○ Muestra el equipo de desarrollo y cuáles fueron sus roles.

32
 App de Diario Personal
MANUAL TÉCNICO

Detalles de Implementación
La aplicación de notas se centra en la gestión eficiente de la creación, edición,

organización.

Algoritmos

● Creación de Notas

○ El usuario ingresa la nota.

○ Se agrega un identificador numérico

○ Se guarda la nota en la base de datos local.

● Edición de Nota

○ Se selecciona una nota ya existente.

○ Se modifica el título o el contenido.

○ Se actualiza el almacenamiento.

● Búsqueda de la Nota

○ Se recibe la consulta por parte del usuario.

○ Se realiza una comparación de la consulta con los datos existentes.

○ Muestra los resultados y valida la búsqueda realizada.

Lógica de Negocio

La aplicación le da acceso a sus usuarios de crear sus notas sin límite de caracteres

para su contenido. Siempre y cuando su almacenamiento interno lo permita. Permite la

edición de notas cuantas veces sea necesario.

Detalles sobre bases de datos y esquemas de datos.

Nuestra base de datos para la app de diario de notas fue diseñado para ser sencillo y

eficiente, esto lo crea permisible para una estructura de datos eficiente. Debido a que la app

es creada para un solo usuario, se ha utilizado SQLite para que el almacenamiento sea

localmente.
33
 App de Diario Personal
MANUAL TÉCNICO

Estructura de datos

Cada nota contiene estos 3 elementos al ser almacenados en la base de datos.

● Id: identificador de la nota

● Título: encabezado de la nota

● Contenido:

Diagrama de la base de datos

El diseño de la base de datos y los esquemas de datos aseguran que la aplicación de

diario de notas sea flexible y eficiente, proporcionando una base sólida para la gestión y

acceso a las notas del usuario

34
 App de Diario Personal
MANUAL TÉCNICO

Mantenimiento y Actualizaciones
Para su mantenimiento recomendamos depuración constante de la memoria caché y

una revisión regular.

Posibles actualizaciones

● Recuperación de contraseña

● Inicio de sesión para un almacenamiento en la nube

35
 App de Diario Personal
MANUAL TÉCNICO

Referencias y Recursos Adicionales

Documentacion de Kotlin: Kotlin documentation as PDF | Kotlin Documentation

(kotlinlang.org)

36