A minor project

On
(Notes and Password Manager)

An automatic password generator and Notes manager application

Batchelor’s of Computer Applications

BCA(2020-2023)
Head of Department: Prof (Dr) Kavita Gupta
Submitted to: Submitted by:
Pritpal Kaur | E11556 Gitanshu Kumar | 20BCA1699

Tamanna Chandel | 20BCA1263

UNIVERSITY INSTITUTE OF COMPUTING, CHANDIGARH UNIVERSITY

Mohali, NH-95, Ludhiana - Chandigarh State Hwy, Punjab 140413

 BONAFIDE CERTIFICATE

Certified that this project report “NOTES AND PASSWORD MANAGER” an automatic
password generator and Notes manager application” is the bonafide work of
“20BCA1699(Gitanshu Kumar)” and “20BCA1263(Tamanna Chandel)” who carried out the
project work under my/our supervision.

SUPERVISOR HEAD OF THE DEPARTMENT

Pritpal Kaur Dr. Kavita Gupta

SIGNATURE SIGNATURE

Submitted for the project viva-voce examination held on_____________________

INTERNAL EXAMINER EXTERNAL EXAMINER

ACKNOWLEDGEMENT
I express my sincere regard and indebtedness to my project guide Ms. Pritpal Kaur,
Supervisor, Department of UNIVERSITY INSTITUTE OF COMPUTING,
Chandigarh University, Punjab for his valuable time, guidance, encouragement,
support and cooperation throughout the duration of our project. I would sincerely
like to thank our Department for giving me the opportunity to work on enhancing
my technical skills while undergoing this project.

We are really thankful to all of my friends who always advised and motivated me
throughout the course.

ABSTRACT
The main objective of the Notes and Password Manager is to provide random
password every time when clicked, It can customized according to user like if
whether they want to add symbols, numbers small case letters or upper case
letters, even length of the password can be customized. The project is totally
built at user end and thus anyone can guaranteed the access. The purpose of the
project is to build an program to reduce the manual work for thinking about
security and creating strong password.

As well as Notes also very secure we can use any time, in this application
notes data also never lost because Notes data auto save on Firbase.

Table Of Contents
Title
Page……………………………………………………………………………………
…… 1

Bonafide
Certificate………………………………………………………………………… 2

Acknowledgement……………………………………………………………………
…… 3

Abstract………………………………………………………………………………
………….. 4

Chapter 1 (INTRODUCTION)…………………………………… 7-14

1.1 Introduction……………………………………………………… 7
1.2 Aim………………………………………………………………… 8
1.3 Feasibility Study…………………………………………………… 9
1.3.1 Operational Feasibility……………………………… 10
1.3.2 Technical Feasibility…………………....................... 11
1.3.3 Economical Feasibility……………….. …………….. 12

1.4 Timeline of the Project……………………………………………. 13-14

Chapter 2 (LITERATURE SURVEY)……………………………… 15-24

2.1 What is objective of Notes and password manager? …………. 15
2.2 What are the benefits of Notes and Password manager? .................... 16
2.3 Purpose of Notes and password manager ………………………………. 16
2.4 Features/Characteristic……………………………………….. 16-18
2.5 Goals and objectives of the project…………………………… 19-20
2.6 Importance…………………………………………………….. 20-21
2.7 Problems in project ……………………………………………. 22
2.8 Problem Identification…………………………………………. 22-24

Chapter 3 (DESIGN FLOW / PROCESS )…………………..………… 25-42

3.1 Software development life cycle ……………………………… 25

3.1.1 Waterfall Model………………………………. 25-26
 3.1.2 Diagram……………………………………….. 27
3.2 Framework ………………………………………….. 28-31
3.2.1 .Xml…………………………………………. 28-29
3.2.2 Java…………………………………… 30-31
3.3 Back end languages………………………………………….. 32-35
3.3.1 Firebase……………………………………………. 32-35
3.4 Features……………………………………………………….. 36-38
3.5 Constraint Identification …………………………………… 38- 43
3.5.1 Regulation and design constraint…………... 38
3.5.2 Economic , environmental , health ,

Manufacturabiliy and safety constraint……………39

3.5.3 Professional and ethical issue………………… 39-40

3.5.4 Analysis and feature finalization constraint……40
3.5.5 Generate multiple design ………………………..40-41
3.6 Selection of best design and implementation …………………. 41-43

Chapter 4 (RESULT ANALYSIS AND VALIDATION)…… ……….. 44-49

4.1 Testing and Implementation …………………………………. 44-46

4.2 System testing ………………………………………………… 47
4.3 Software verification and validation………………………….. 48
4.3.1 Introduction……………………………………. 48-49

Chapter 5 (CONCLUSION AND FUTURE WORK)…….................. 50-52

5.1 Conclusion ……………………………………………………. 50

5.2 Future Work………………………………………………….. 51-52
5.3Coding and design…………………………………………………………53
 Chapter: 1 Introduction
1.1 INTRODUCTION
Passwords provide the first line of defense against unauthorized
access to your computer and personal information. The stronger
your password, the more protected your computer will be from
hackers and malicious software.
Passwords are important. They help your personal accounts stay
private and secure but, if you’re guilty of reusing, rotating, or using
notoriously easy passwords, you are leaving yourself open to an
account breach. Therefore, you should know what makes a strong
password so that you can ensure the maximum security for your
sensitive information.
Notes app is used for making short text notes, update when you
need them, and trash when you are done. It can be used for various
functions as you can add your to-do list in this app, some important
notes for future reference, etc. The app is very useful in some cases
like when you want quick access to the notes. Likewise, here let’s
create an Android App to learn how to create a simple NotesApp.
So in this article let’s build a Notes App in which the user can add
any data, remove any data as well as edit any data. A sample GIF
is given below to get an idea about what we are going to do in this
article. Note that we are going to implement this project using the
Java language.
1.2 AIM

Why is Password Security Important?

Repeatedly using the same passwords or using ‘weak’ passwords can
leave you vulnerable to hackers. If a hacker cracks your passwords, they
could gain access to your social media accounts, bank accounts, emails
and other sensitive accounts that hold your confidential, personal data. If
someone obtains access to this information, you could become the victim
of identity theft. Therefore, creating a strong password is vital.
Password hacking is often carried out in one of the following ways:
1. Brute force attacks. A hacker uses automated software to guess your
username and password combination. The software tries every
possible character combination and will try the most commonly used
passwords first, so weak or common passwords can be relatively
simple for a brute force attack to crack.
2. Dictionary. With this method of hacking, a hacker will run a defined
‘dictionary’ against your passwords. This dictionary also includes the
most common password combinations; therefore, it is a
 relatively easy and quick way of hacking into weakly protected
accounts.

1.3 FEASIBILITY STUDY

A feasibility study is a high-level capsule version of the entire System
analysis and Design Process. The study begins by classifying the problem
definition. Feasibility is to determine if it’s worth doing. Once an
acceptance problem definition has been generated, the analyst develops a
logical model of the system. A search for alternatives is analyzed
carefully. There are 3 parts in feasibility study.

1) Operational Feasibility

2) Technical Feasibility

3) Economical Feasibility
1.3.1 OPERATIONAL FEASIBILITY

Operational feasibility is the measure of how well a proposed system solves the
problems, and takes advantage of the opportunities identified during scope definition and
how it satisfies the requirements identified in the requirements analysis phase of system
development.The operational feasibility assessment focuses on the degree to which the
proposed development projects fits in with the existing business environment and
objectives with regard to development schedule, delivery date, corporate culture and
existing business processes.To ensure success, desired operational outcomes must be
imparted during design and development. These include such design-dependent
parameters as reliability, maintainability, supportability, usability, producibility,
disposability, sustainability, affordability and others. These parameters are required to be
considered at the early stages of design if desired operational behaviours are to be
realised. A system design and development requires appropriate and timely application of
engineering and management efforts to meet the previously mentioned parameters. A
system may serve its intended purpose most effectively when its technical and operating
characteristics are engineered into the design. Therefore, operational feasibility is a
critical aspect of systems engineering that needs to be an integral part of the early design
phases.
1.3.2 TECHNICAL FEASIBILITY

This involves questions such as whether the technology needed for the system
exists, how difficult it will be to build, and whether the firm has enough
experience using that technology. The assessment is based on outline design of
system requirements in terms of input, processes, output, fields, programs and
procedures. This can be qualified in terms of volume of data, trends, frequency
of updating inorder to give an introduction to the technical system. The
application is the fact that it has been developed on windows XP platform and
a high configuration of 1GB RAM on Intel Pentium Dual core processor. This
is technically feasible .The technical feasibility assessment is focused on
gaining an understanding of the present technical resources of the organization
and their applicability to the expected needs of the proposed system. It is an
evaluation of the hardware and software and how it meets the need of the
proposed system.
1.3.3 ECONOMICAL FEASIBILITY

Establishing the cost-effectiveness of the proposed system i.e. if the benefits

do not outweigh the costs then it is not worth going ahead. In the fast paced
world today there is a great need of online social networking facilities. Thus
the benefits of this project in the current scenario make it economically
feasible. The purpose of the economic feasibility assessment is to determine
the positive economic benefits to the organization that the proposed system
will provide. It includes quantification and identification of all the benefits
expected. This assessment typically involves a cost/benefits analysis.
1.4 Timeline of the project

Week 1

Research and planning of project with team members and submitting project proposal.

Week 2-4

Start working on the project and decide the roles of team members and give 2nd project
report.

Week 5-7

Review the work done and test the progress as scheduled.

Week 8-9

Bug fixes and changes in the project if required and making project report of progress.

Week 10-13
 Check and test the project output and fix any bugs or complete any changes required and
make presentation of final project and report.

Total weeks: 13

Chapter 2: Literature survey

2.1 What is the objective of NOTES AND PASSWORD MANAGER?

The objectives of this study is as follows ;

 To evaluate the way of make internet more secure.

 To develop a system from where user can strong password within just click.
 To determine the security needs that it can fulfill if needed the concept of cryptography
can also be involved in this.
 To develop a system that will surely satisfied the user needs.
  To design a system able to accommodate huge amount of time for thinking for passwords.
 To evaluate its performance and acceptability in terms of security, user-friendliness,
accuracy and reliability.
 To improve the communication between the client and the server.
 We never lost our save notes data.
 It’s very Secure.
2.2 What are the benefits of NOTES AND PASSWORD MANAGER?

One of the advantages of NOTES AND PASSWORD MANAGER for users is that it ensures
passwords are accurate and there’s less room for error. By giving it format of browser
extension. By every, click it will generate random and strong password for user that
they can use it for different purposes.
User got Two task on single platform.
They can also use Notes and save their notes. In this application User never Lost
their data.
2.3 What is the purpose of NOTES AND PASSWORD MANAGER?

So, keeping above things in mind I’ll make an algorithm which will automatically
generate strong password using different symbols, number and alphabets. By giving
it format of browser extension. By every, click it will generate random and strong
password for user that they can use it for different purposes.
As well as Notes also Very secure. E can access our Notes data Anywhere and
anytime After Login.
2.4 Feature/Characteristic

 Made with Java which has big community to support.

 Improved performance: Easily detect & resolve issues with
our pre-built, customizable dashboards.
 Reusable components: pre-built pieces of programming
code designed to perform a specific function.
 In this project we also used .xml.
 One of the most important features of .xml is XML tags
define the data and used to store and organize data. It's
 easily scalable and simple to develop. In Android, the
XML is used to implement UI-related data, and it's a
lightweight markup language that doesn't make layout
heavy. XML only contains tags, while implementing they
need to be just invoked.
XML separates data from HTML

2.5 What are the goals and objectives of our project ?

Password: m#P52s@ap$V
This is a great example of a strong password. It's strong, long,
and difficult for someone else to guess. It uses more than
10 characters with letters
(both uppercase and lowercase), numbers, and symbols, and
includes no obvious personal information or common words.
Like this I would create an algorithm which will generate
strong password like this, to enhance user security over
internet.
We can also save and create notes any time in this application.

2.6 Importance

So, here the clint will be the normal user and students,
they are login in so many websites these days for
different purposes, websites like google, Facebook,
Instagram, GitHub, LinkedIn, and many more. For
different purposes.
And as even google suggest not to use same password
for different purposes.

So, considering the need of security I am introducing

this project which will fulfill the need in the market for
security reasons.
And this application also provides Single platform two
task Because Password generator generate random
password which we can Copy that password and Save
in the Notes.

2.7 Problems in project

There are also some limitations of the system. Our system in

not maintaining any databases for given passwords, so there
 may be a chance that passwords can repeat, Although chances
are very less. Along with this, validation functionalities and
almost all functionalities of the application are handled with
server-side programming. It makes extra load on the server,
especially when the application gets lots of viewers. This
limitation can be minimized by validating data using client-
side language like JavaScript or HTML 5.

2.8 Problem Identification

You'll need to create a password to do just about
everything on the Web, from checking your email to
online banking. And while it's simpler to use a short,
easy-to-remember password, this can also pose serious
risks to your online security. To protect yourself and
your information, you'll want to use passwords that are
long, strong, and difficult for someone else to guess while
still keeping them relatively easy for you to remember.

At this point, you may be wondering, why do I even need a

strong password anyway? The truth is that even though
most websites are secure, there's always a small chance
someone may try to access or steal your information. This is
commonly known as hacking. A strong password is one of
the best ways to defend your accounts and private
information from hackers.

Chapter 3: Design flow/Process

3.1 Software Development Life Cycle Model

3.1.1 WATERFALL MODEL

The waterfall model was selected as the SDLC model due to the following
reasons:

 Requirements were very well documented, clear and fixed.

 Technology was adequately understood.
 Simple and easy to understand and use.
 There were no ambiguous requirements.
 Easy to manage due to the rigidity of the model. Each phase has specific
deliverables and a review process.
 Clearly defined stages.
 Well understood milestones. Easy to arrange tasks.
3.1.2Diagram –

This project would be containing:

1. Basic .xml. Better designed buttons, text fields.

2. Logic & Working Java. Whole logic of the code and working
will be embedded in Java.
3. At last, I’ll will be connecting it to Firebase which would we
very useful for every user .
In this Section we will do Analysis of Technologies to use for implementing
the project.

3.2 : FRONT END

XML stands for eXtensible Markup Language
XML is a markup language much like HTML
XML was designed to store and transport data
XML was designed to be self-descriptive
XML simplifies data sharing
XML simplifies data transport
XML simplifies platform changes
XML simplifies data availability.
3.2.1 Java

JAVA was developed by James Gosling at Sun Microsystems Inc in the year
1995, later acquired by Oracle Corporation. It is a simple programming
language. Java makes writing, compiling, and debugging programming easy. It
helps to create reusable code and modular programs. Java is a class-based,
object-oriented programming language and is designed to have as few
implementation dependencies as possible. A general-purpose programming
language made for developers to write once run anywhere that is compiled
Java code can run on all platforms that support Java. Java applications are
compiled to byte code that can run on any Java Virtual Machine. The syntax of
Java is similar to c/c++.

History: Java’s history is very interesting. It is a programming language

created in 1991. James Gosling, Mike Sheridan, and Patrick Naughton, a team
of Sun engineers known as the Green team initiated the Java language in 1991.
Sun Microsystems released its first public implementation in 1996 as Java 1.0.
It provides no-cost -run-times on popular platforms. Java1.0 compiler was re-
written in Java by Arthur Van Hoff to strictly comply with its specifications.
With the arrival of Java 2, new versions had multiple configurations built for
different types of platforms.

In 1997, Sun Microsystems approached the ISO standards body and later
formalized Java, but it soon withdrew from the process. At one time, Sun made
most of its Java implementations available without charge, despite their
proprietary software status. Sun generated revenue from Java through the
selling of licenses for specialized products such as the Java Enterprise System.

On November 13, 2006, Sun released much of its Java virtual machine as free,
open-source software. On May 8, 2007, Sun finished the process, making all of
its JVM’s core code available under open-source distribution terms.
3.2.2

Firebase
   

Firebase is a product of Google which helps developers to build, manage, and

grow their apps easily. It helps developers to build their apps faster and in a
more secure way. No programming is required on the firebase side which
makes it easy to use its features more efficiently. It provides services to
android, ios, web, and unity. It provides cloud storage. It uses NoSQL for the
database for the storage of data.
Mainly there are 3 categories in which firebase provides its services.

Build better applications

This feature mainly includes backend services that help developers to build
and manage their applications in a better way. Services included under this
feature are :

Realtime Database: The Firebase Realtime Database is a cloud-based NoSQL

database that manages your data at the blazing speed of milliseconds. In
simplest term, it can be considered as a big JSON file.

Cloud Firestore: The cloud Firestore is a NoSQL document database that

provides services like store, sync, and query through the application on a
global scale. It stores data in the form of objects also known as Documents. It
has a key-value pair and can store all kinds of data like, strings, binary data,
and even JSON trees.

3.4 Features –

So, here the clint will be the normal user and students,
they are login in so many websites these days for
different purposes, websites like google, Facebook,
Instagram, GitHub, LinkedIn, and many more. For
different purposes.

And as even google suggest not to use same password

for different purposes.
 So, considering the need of security I am
introducing this project which will fulfill the need in
the market for security reasons.

3.5 Constraint Identification

3.5.1 Regulations & Design constraints considered in design:-

o This project keeps restrictions in password security.
o The user has freedom to construct its password according to
their need.
o The cryptography concept was kept in mind while designing this
architecture.
o This program won’t grant any access to the database of the
program.
o The login credentials aren’t kept in this program, as this is just
an extension. Login might be overburden.
 o Structural Integrity of program. This element involves
technological reasoning that ensures the proper performance of a
product so that it is useful in supporting an activity.
o Aesthetics of program. This element is sometimes a puzzling
subject for scientists and engineers, but for the designer it is the
final element in the creation of a complete product. 

3.5.2 Economic, environmental, health, manufacturability & safety

constraints considered in design :-
‘Health and Safety by Design’ is the process of managing health and safety
risks throughout the lifecycle of structures, plant, substance or other
products. Designers are in a strong position to make work healthy and
safe from the start of the design process.
Good design reduces damage to property and the environment, and the
related costs.It is more efficient and effective to manage risk in the
design phase than to retrofit health and safety solutions. SMART DESIGN
OF PRODUCTS MAKES GOOD BUSINESS SENSE

3.5.3 Professional and ethical issues considered in design:-

Design ethics concerns moral behavior and responsible choices in the practice of
design. It guides how designers work with clients, colleagues, and the end users of
products, how they conduct the design process, how they determine the features of
products, and how they assess the ethical significance or moral worth of the
products that result from the activity of designing. Ethical considerations have
always played a role in design thinking, but the development of scientific
knowledge and technology has deepened awareness of the ethical dimensions of
design. As designers incorporate new knowledge of physical and human nature as
well as new forms of technology into their products, people are increasingly aware
of the consequences of design for individuals, societies, cultures, and the natural
environment
 3.5.4 Analysis and feature finalization subject to constraint :-

With any project, there are limitations and risks that need to be addressed to ensure the
project’s ultimate success. The three primary constraints that project managers should be
familiar with are time, scope, and cost. These are frequently known as the triple constraints
or the project management triangle. Each constraint is connected to the other two; so, for
example, increasing the scope of the project will likely require more time and money, while
speeding up the timeline for the project may cut costs, but also diminish the scope.

3.5.5 Generate multiple design alternates.:-

When a product is available in different designs where all the designs share the same
components, but the arrangement of those components is different in different designs,
they are referred as design alternatives .Good designers try to generate as many
possible solutions as they can before choosing one that they feel is the best. This
creative process of developing ideas is called ideation.

Methods of ideation include:

 Examining existing solutions

 Creating and using analogies

 Conducting brainstorming sessions

 Sketching and doodling

3.6 Selection of best design and implementation plan :-
In any program or ongoing process, the designing the project is the backbone element. Every
project that moves from the development process is unique, with many different scenarios
applying to it. However, they all have something in common, the Best Project Design.

Project design is so important that there is no structure for the project development process to
stand on and make the project a success in the future. It is such a crucial stage in a project's
lifecycle that it identifies key elements and sets the overall tone of the project. To have a
successful project, you need to understand the steps involved in project design

The best project design provides a strategic organization of ideas, materials, and processes to

achieve a goal. Project managers use a good design to avoid pitfalls and give parameters to
maintain crucial aspects of the project, like the schedule and the budget. Lots of project
managers rush into the initialization of the project. Still, an experienced project manager will
tell you that the more you invest in your project's front end, the better your results will get at the
backend.

Chapter 4 Results analysis and validation

4.1 TESTING AND IMPLEMENTATION

The term implementation has different meanings ranging from the

conversation of a basic application to a complete replacement of a computer
system. The procedures however, are virtually the same. Implementation
includes all those activities that take place to convert from old system to new.
The new system may be totally new replacing an existing manual or automated
system or it may be major modification to an existing system. The method of
implementation and time scale to be adopted is found out initially. Proper
implementation is essential to provide a reliable system to meet organization
requirement.

DESCRIPTION OF TEST CASE:-

1. ERRORS:- The term error is used to verified the log in password, balance
amount and account searching stage.Due to this the correct user and correct
utilization of software responsible.

2. FAULT:- It is a condition where the system deny furtherprocess.

3. FAILURE:- It is the main ability of a system to perform required function

account to specification. The software failure occurs when the behavior of
software is different from specified condition.

4. UNIT TESTING:-The program unit is usually small enough that the

programmer can test it in great details and certainly in greater details than
will be possible when the unit integrated into an involving software product.

5. MODULE TESTING:-The module relate can be tested without involving

other system modules.

There are five categories of testing which are as

follows:-
 Functional test
 2.Performance test
 Structured test
 UserSatisfaction test
 5 Security Testing
  Functional Test:- It involves exercising the code with nominal input
value which expected result are known as well as boundary values such
as minimum and maximum. The usual software testing activities like
test case preparation, test case preview and test case execution is done
during this phase.

 Performance Test:- It determines the amount of execution time spent

in various parts of unit, program response time and device utilization by
the program unit.

 Structured Test:- It concerned with exercising the internal logic of

program and trans versing execution path.

 User Satisfaction Test:- It concerned with user comments as well as

account holder comments.

 Security Testing:- It will ensure that a software does not have any security
flows. During test preparation quality, analysis team need to include both
negative as well as positive scenario so as to break into the system and report
it before any unauthorized individual access.

4.2 : SYSTEM TESTING

System testing of software or hardware is testing conducted on a complete,

integrated system to evaluate the system's compliance with its
specified requirements. System testing falls within the scope of black-box
testing, and as such, should require no knowledge of the inner design of the
code or logic. As a rule, system testing takes, as its input, all of the
"integrated" software components that have passed integration testing and also
the software system itself integrated with any applicable hardware system(s).
The purpose of integration testing is to detect any inconsistencies between the
software units that are integrated together (called assemblages) or between any
of the assemblages and the hardware. System testing is a more limited type of
testing; it seeks to detect defects both within the "inter-assemblages" and also
within the system as a whole.

System testing is performed on the entire system in the context of a Functional

Requirement Specification(s) (FRS) and/or a System
Requirement Specification (SRS). System testing tests not only the design, but
also the behavior and even the believed expectations of the customer. It is also
intended to test up to and beyond the bounds defined in the software/hardware
requirements specification(s).

4.3 : SOFTWARE VERIFICATION AND VALIDATION

4.3.1 Introduction
In software project management, software testing, and software engineering, verification
and validation (V&V) is the process of checking that a software system meets
specifications and that it fulfills its intended purpose. It may also be referred to
as software quality control. It is normally the responsibility of software testers as part of
the software development lifecycle. Validation checks that the product design satisfies or
fits the intended use (high-level checking), i.e., the software meets the user
requirements.This is done through dynamic testing and other forms of review.
Verification and validation are not the same thing, although they are often
confused. Boehm succinctly expressed the difference between

 Validation : Are we building the right product?

 Verification : Are we building the product right?

According to the Capability Maturity Model (CMMI-SW v1.1)

Software Verification: The process of evaluating software to determine whether the

products of a given development phase satisfy the conditions imposed at the start of that
phase.

Software Validation: The process of evaluating software during or at the end of the
development process to determine whether it satisfies specified requirements.

In other words, software verification is ensuring that the product has been built according
to the requirements and design specifications, while software validation ensures that the
product meets the user's needs, and that the specifications were correct in the first place.
Software verification ensures that "you built it right". Software validation ensures that
"you built the right thing". Software validation confirms that the product, as provided,
will fulfill its intended use.

From Testing Perspective

 Fault – wrong or missing function in the code.

  Failure – the manifestation of a fault during execution.
 Malfunction – according to its specification the system does not meet its
specified functionality

Both verification and validation are related to the concepts of quality and

of software quality assurance. By themselves, verification and validation do
not guarantee software quality; planning, traceability, configuration
management and other aspects of software engineering are required. Within
the modeling and simulation (M&S) community, the definitions of
verification, validation and accreditation are similar:

 M&S Verification is the process of determining that a ⦁ computer model,

simulation, or federation of models and simulations implementations and
their associated data accurately represent the developer's conceptual
description and specifications.
 M&S Validation is the process of determining the degree to which a
model, simulation, or federation of models and simulations, and their
associated data are accurate representations of the real world from the
perspective of the intended use(s).

Chapter 5: Conclusion and future work

Creating strong passwords

You'll need to create a password to do just about everything on the Web, from checking
your email to online banking. And while it's simpler to use a short, easy-to-remember
password, this can also pose serious risks to your online security. To protect yourself and
your information, you'll want to use passwords that are long, strong, and difficult for
someone else to guess while still keeping them relatively easy for you to remember.

Why do I need a strong password?

At this point, you may be wondering, why do I even need a strong password anyway? The
truth is that even though most websites are secure, there's always a small chance someone
may try to access or steal your information. This is commonly known as hacking. A strong
password is one of the best ways to defend your accounts and private information from
hackers.

Common password mistakes

Some of the most commonly used passwords are based on family names, hobbies, or just
a simple pattern. While these types of passwords are easy to remember, they're also some
of the least secure. Let's take a look at some of the most common password mistakes and
how to fix them.
 PROBLEM
This password uses too much personal information,
along with common words that could be found in the
dictionary.
SOLUTION
A stronger version of this password would use symbols,
uppercase letters, and a more random order. And rather
than using family names, we could combine a character
from a movie with a type of food. For example,
Chewbacca and pizza could become chEwbAccAp!ZZa.

Problem 2
At only five characters, this password is way too short. It
also includes part of her address, which is publicly
available information.

SOLUTION
A stronger version of this password would be much
longer, ideally more than 10 characters. We could also
substitute a nearby street name instead of her current
address. For example, Pemberly Ave could
become p3MberLY%Av.
 Problem 3
While patterns like this are easy to remember, they're
also some of the first things a hacker might guess when
attempting to access your account.

SOLUTION
Remember that random passwords are much stronger
than simple patterns. If you're having trouble creating a
new password, try using a Notes and password Manager
instead which is automatic password generator. Here's
an example of a generated password: #eV$pIg&qf.
 Problem 3
There's nothing really wrong with this password, but
remember that you should never use the same password
with different accounts.

SOLUTION
Create a unique password for each of your online
accounts.
 Analysis
A strong password should contain a combination of
lower and upper-case letters, numbers, and special
characters. Password cracking tools will start with
shorter password guesses before going on to larger
phrases, therefore the overall length of the password is
even more crucial than the characters utilized. A strong
password should be at least 12 characters long and
contain a variety of characters. So it's up to you to
customize your password with these informations.
Why Randomness is important?
Another typical kind of password attack is to use
common English words that many people are familiar
with. The attackers will guess combinations of common
dictionary words in an attempt to get access, which is
known as a "dictionary attack." As a result, the best
passwords will contain a mix of characters, symbols,
numbers, and words.
 Design/Implement Structure
Random Password Generator and Password manager
built with Java and xml.
NOTES AND PASSWORD MANAGER
It is an application that generates random or
personalized passwords for users. It assists users in
creating stronger passwords that are more secure for a
certain sort of access.
And also user create their Notes.

Built Using
Java
Firebase
xml
For others plugins and dependencies take a look at
package.

Setup
Task 1
Environment & Firebase setup
Before the start of any development procedure, we need
to set up the environment
according to our application needs. Then connect your
Android Studio with Firebase.
Requirements
• Install Android Studio on your machine.
• Install and set up JDK.
• Create a new Android project.
• Like any typical application, the source code of Java
should be in a java folder and the
source code of XML should be in a res folder.
• Connect with Firebase.

Task 2
Setting up Firebase and Authentication
Firebase is a great service provided by Google for
configuring the backend of any
application with all the general necessities like database
preparation, authentication using
various methods, etc. In this milestone, we’ll be
preparing our database and setting up
authentication using email and password.
[Note: Use the references provided to implement the
following requirements.]
Requirements
• Setup sign-in method using Email/Password.
• Declare the dependency for the Firebase Authentication
Android library in your
module ( app-level ) Gradle file ( usually app/build.gradle
).
dependencies {
// Import from the Firebase platform
implementation
platform('com.google.firebase:firebase-bom:26.3.0')
Task 3
Creating home activity
Now we will create an activity where there will be two
options note and password.
• Style the activity so that it looks similar to the one
shown below
 Things used in project

Java: Java is a class-based object-oriented simple

programming language. Though we can not consider it to be
fully object-oriented as it supports primitive datatypes. It is a
general-purpose, high-level programming language that helps
programmers and developers to write a code once and run it
anywhere.

Java is considered both a compiled and interpreted language.

It is because Java source code is first compiled to bytecode
which is then interpreted by Java Virtual Machine. Java
Virtual Machine interprets the bytecode and converts it to
platform specific machine code. Hence, Java is also called a
platform-independent programming language.
xml: XML (Extensible Markup Language) is a markup
language similar to HTML, but without predefined tags to
use. Instead, you define your own tags designed
specifically for your needs. This is a powerful way to store
data in a format that can be stored, searched, and shared.
Most importantly, since the fundamental format of XML is
standardized, if you share or transmit XML across systems
or platforms, either locally or over the internet, the
recipient can still parse the data due to the standardized
XML syntax.

There are many languages based on XML, including

XHTML, MathML, SVG, RSS, and RDF. You can also define
your own. 

Coding
1. HomeActivity

 package com.example.myapplication;

import androidx.appcompat.app.AppCompatActivity;

import android.annotation.SuppressLint;
import android.content.Intent;
import android.os.Bundle;
 import android.view.View;
import android.widget.Button;

public class HomeActivity extends AppCompatActivity {

private Button move;

@SuppressLint("MissingInflatedId")
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_home);
setContentView(R.layout.activity_pass);
move=findViewById(R.id.button1);
move=findViewById(R.id.button2);
move.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent=new Intent(HomeActivity.this,NotesActivity.class);
Intent intent1=new Intent(HomeActivity.this,PassActivity.class);

startActivity(intent);
}
});
}

2.Login Activity
package com.example.myapplication;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.app.ProgressDialog;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.auth.AuthResult;
import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;

public class LoginActivity extends AppCompatActivity {

TextView createnewAccount;
EditText inputEmail, inputPassword, inputConformPassword;
Button btnLogin;
String emailPattern = "[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,4}$";
ProgressDialog progressDialog;
 FirebaseAuth mAuth;
FirebaseUser mUser;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
setContentView((R.layout.activity_login));
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);

inputEmail = findViewById(R.id.inputEmail);
inputPassword = findViewById(R.id.inputConformPassword);
btnLogin = findViewById(R.id.btnlogin);
progressDialog = new ProgressDialog(this);
mAuth = FirebaseAuth.getInstance();
mUser = mAuth.getCurrentUser();

TextView btn = findViewById(R.id.textViewSignUp);

btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(LoginActivity.this, RegisterActivity.class));
}
});
btnLogin.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
perforLogin();
}
});

private void perforLogin() {

String email = inputEmail.getText().toString();
String password = inputPassword.getText().toString();

if (!email.matches(emailPattern)) {
inputEmail.setError("Enter Correct Email");
} else if (password.isEmpty() || password.length() < 6) {
inputPassword.setError("Enter Proper Password");
} else {
progressDialog.setMessage(" Please Wait while Login");
progressDialog.setTitle("Login");
progressDialog.setCanceledOnTouchOutside(false);
progressDialog.show();

mAuth.signInWithEmailAndPassword(email,password).addOnCompleteListener(new
OnCompleteListener<AuthResult>() {
@Override
public void onComplete(@NonNull Task<AuthResult> task) {
if (task.isSuccessful())
{
progressDialog.dismiss();
sendUserToNextActivity();
Toast.makeText(LoginActivity.this,"Login
Successful",Toast.LENGTH_SHORT).show();
 }
else
{
progressDialog.dismiss();
Toast.makeText(LoginActivity.this,
""+task.getException(),Toast.LENGTH_SHORT).show();
}
}
});
}
}
private void sendUserToNextActivity() {
Intent intent=new Intent(LoginActivity.this,HomeActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK|Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
}
3Notes
package com.example.myapplication;

import com.google.firebase.Timestamp;

public class Note {

String title;
String content;
Timestamp timestamp;

public Note() {
}

public String getTitle() {

return title;
}

public void setTitle(String title) {

this.title = title;
}

public String getContent() {

return content;
}

public void setContent(String content) {

this.content = content;
}

public com.google.firebase.Timestamp getTimestamp() {

return timestamp;
}

public void setTimestamp(com.google.firebase.Timestamp timestamp) {

this.timestamp = timestamp;
}
}
4.Notes Adapter
package com.example.myapplication;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import com.firebase.ui.firestore.FirestoreRecyclerAdapter;
import com.firebase.ui.firestore.FirestoreRecyclerOptions;

import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;

public class NoteAdapter extends FirestoreRecyclerAdapter<Note,

NoteAdapter.NoteViewHolder> {
Context context;

public NoteAdapter(@NonNull FirestoreRecyclerOptions<Note> options, Context context) {

super(options);
this.context= context;
}

@Override
protected void onBindViewHolder(@NonNull NoteViewHolder holder, int position, @NonNull
Note note) {
holder.titleTextView.setText(note.title);
holder.contentTextView.setText(note.content);
holder.timestampTextView.setText(Utility.timestampToString(note.timestamp));

@NonNull
@Override
public NoteViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View view =
LayoutInflater.from(parent.getContext()).inflate(R.layout.recycler_note_item,parent,false)
;
return new NoteViewHolder(view);
}

class NoteViewHolder extends RecyclerView.ViewHolder{

TextView titleTextView,contentTextView,timestampTextView;

public NoteViewHolder(@NonNull View itemView) {

super(itemView);
titleTextView = itemView.findViewById(R.id.note_title_text_view);
contentTextView = itemView.findViewById(R.id.note_content_text_view);
timestampTextView = itemView.findViewById(R.id.note_timestamp_text_view);

}
}
}
5.NotesDetailsActivity
package com.example.myapplication;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.widget.EditText;
import android.widget.ImageButton;

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.Timestamp;
import com.google.firebase.firestore.DocumentReference;

public class NoteDetailsActivity extends AppCompatActivity {

EditText titleEditText,contentEditText;
ImageButton saveNoteBtn;

@SuppressLint("MissingInflatedId")
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_note_details);
titleEditText=findViewById(R.id.notes_title_text);
contentEditText=findViewById(R.id.notes_content_text);
saveNoteBtn=findViewById(R.id.save_note_btn);
saveNoteBtn.setOnClickListener((v)-> saveNote());
}
void saveNote() {
String noteTitle = titleEditText.getText().toString();
String noteContent = contentEditText.getText().toString();
if (noteTitle == null || noteTitle.isEmpty()) {
titleEditText.setError("Title is Required");
return;
}
Note note = new Note();
note.setTitle(noteTitle);
note.setContent(noteContent);
note.setTimestamp(Timestamp.now());

saveNoteToFirebase(note);

}
void saveNoteToFirebase(Note note){
DocumentReference documentReference;
documentReference = Utility.getCollectionReferenceForNotes().document();
documentReference.set(note).addOnCompleteListener(new OnCompleteListener<Void>() {
@Override
public void onComplete(@NonNull Task<Void> task) {
if(task.isSuccessful()){
Utility.showToast(NoteDetailsActivity.this,"Note added Successfully");
finish();
}
else {
Utility.showToast(NoteDetailsActivity.this,"Faild wile adding the
note");

}
}
});
 }
}
5.NotesActivity
package com.example.myapplication;

import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import android.annotation.SuppressLint;
import android.content.Intent;
import android.os.Bundle;
import android.widget.ImageButton;

import com.firebase.ui.firestore.FirestoreRecyclerOptions;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
import com.google.firebase.firestore.Query;

public class NotesActivity extends AppCompatActivity {

FloatingActionButton addNoteBtn;
RecyclerView recyclerView;
ImageButton menuBtn;
NoteAdapter noteAdapter;

@SuppressLint("MissingInflatedId")
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_notes);
addNoteBtn = findViewById(R.id.add_note_btn);
recyclerView = findViewById(R.id.recyler_view);
menuBtn = findViewById(R.id.menu_btn);
addNoteBtn.setOnClickListener((v)-> startActivity(new
Intent(NotesActivity.this,NoteDetailsActivity.class)));
menuBtn.setOnClickListener((v)->showMenu());
setupRecycleView();
}

void showMenu() {

}
void setupRecycleView(){
Query query = Utility.getCollectionReferenceForNotes().orderBy("timestamp",
Query.Direction.DESCENDING);
FirestoreRecyclerOptions<Note> options = new
FirestoreRecyclerOptions.Builder<Note>().setQuery(query,Note.class).build();
recyclerView.setLayoutManager(new LinearLayoutManager(this));
noteAdapter = new NoteAdapter(options,this);
recyclerView.setAdapter(noteAdapter);

@Override
protected void onStart() {
super.onStart();
noteAdapter.startListening();
 }

@Override
protected void onStop() {
super.onStop();
noteAdapter.stopListening();
}

@Override
protected void onResume() {
super.onResume();
noteAdapter.notifyDataSetChanged();
}
6.PassActivity
package com.example.myapplication;

import androidx.appcompat.app.AppCompatActivity;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.util.Random;

public class PassActivity extends AppCompatActivity {

TextView password;
Button btn1;

@SuppressLint("MissingInflatedId")
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_pass);
password = (TextView) findViewById(R.id.password);
btn1 = (Button) findViewById(R.id.btn1);
btn1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
password.setText(generateString(8));
}
});

}
private String generateString(int length){
char[] chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz".toCharArray();
Random r = new Random();
StringBuilder sb = new StringBuilder();
for (int i=0;i<length;i++){
char c = chars[r.nextInt(chars.length)];
sb.append(c);
}
return sb.toString();
}
}
 7.RegisterActivity
package com.example.myapplication;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.app.ProgressDialog;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.auth.AuthResult;
import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;

public class RegisterActivity extends AppCompatActivity {

TextView alreadyHaveaccount;
EditText inputEmail, inputPassword, inputConformPassword;
Button btnRegister;
String emailPattern = "[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,4}$";
ProgressDialog progressDialog;
FirebaseAuth mAuth;
FirebaseUser mUser;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_register);
TextView btn = findViewById(R.id.alreadyHaveAccounnt);
inputEmail = findViewById(R.id.inputEmail);
inputPassword = findViewById(R.id.inputPassord);
inputConformPassword = findViewById(R.id.inputConformPassword);
btnRegister = findViewById(R.id.btnRegister);
progressDialog = new ProgressDialog(this);
mAuth = FirebaseAuth.getInstance();
mUser = mAuth.getCurrentUser();
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(RegisterActivity.this, LoginActivity.class));
}
});
btnRegister.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
perforAuth();

}
});

}
 private void perforAuth() {
String email = inputEmail.getText().toString();
String password = inputPassword.getText().toString();
String confirmPassword = inputConformPassword.getText().toString();
if (!email.matches(emailPattern)) {
inputEmail.setError("Enter Correct Email");
} else if (password.isEmpty() || password.length() < 6) {
inputPassword.setError("Enter Proper Password");
} else if (!password.equals(confirmPassword)) {
inputConformPassword.setError("Password Not Matched");
} else {
progressDialog.setMessage(" Please Wait while Registration....");
progressDialog.setTitle("Registration");
progressDialog.setCanceledOnTouchOutside(false);
progressDialog.show();

mAuth.createUserWithEmailAndPassword(email,
password).addOnCompleteListener(new OnCompleteListener<AuthResult>() {
@Override
public void onComplete(@NonNull Task<AuthResult> task) {
if (task.isSuccessful()) {
progressDialog.dismiss();
sendUserToNextActivity();
Toast.makeText(RegisterActivity.this, "Registration Successful",
Toast.LENGTH_SHORT).show();
} else {
progressDialog.dismiss();
Toast.makeText(RegisterActivity.this, "" + task.getException(),
Toast.LENGTH_SHORT).show();
}
}
});

}
}

private void sendUserToNextActivity() {

Intent intent = new Intent(RegisterActivity.this, HomeActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
}
}
Layout
1.Register
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/bc"
tools:context=".LoginActivity">
<TextView
android:id="@+id/textView"
android:layout_width="138dp"
android:layout_height="44dp"
android:text="Login"
android:textColor="@color/white"
android:textSize="34sp"
android:textStyle="bold"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.443"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.119" />

<EditText
android:id="@+id/inputEmail"
android:layout_width="346dp"
android:layout_height="53dp"
android:layout_marginStart="40dp"
android:layout_marginTop="16dp"
android:background="@drawable/input_bg"
android:drawableLeft="@android:drawable/sym_action_email"
android:drawablePadding="10dp"
android:ems="10"
android:hint="Email"
android:inputType="textPersonName"
android:paddingLeft="20dp"
android:paddingTop="10dp"
android:paddingRight="10dp"
android:paddingBottom="10dp"
android:textColor="@color/white"
android:textColorHint="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="@+id/inputUsername"
app:layout_constraintHorizontal_bias="0.0"
app:layout_constraintStart_toStartOf="@+id/inputUsername"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.256" />

<EditText
android:id="@+id/inputConformPassword"
android:layout_width="342dp"
android:layout_height="53dp"
android:layout_marginStart="20dp"
android:background="@drawable/input_bg"
android:drawableLeft="@android:drawable/ic_lock_lock"
android:drawablePadding="10dp"
android:ems="10"
android:hint="Password"
android:inputType="textPersonName|textPassword"
android:paddingLeft="20dp"
android:paddingTop="10dp"
android:paddingRight="10dp"
android:paddingBottom="10dp"
android:textColor="@color/white"
 android:textColorHint="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="@+id/inputUsername"
app:layout_constraintHorizontal_bias="1.0"
app:layout_constraintStart_toStartOf="@+id/inputUsername"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.398" />

<TextView
android:id="@+id/frgtpass"
android:layout_width="147dp"
android:layout_height="28dp"
android:text="Forgot Password"
android:textColor="@color/white"
android:textSize="16sp"
android:textStyle="normal|bold"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.712"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.499" />

<Button
android:id="@+id/btnlogin"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginStart="32dp"
android:layout_marginTop="8dp"
android:background="@drawable/btn_bg"
android:text="Login"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="@+id/inputConformPassword"
app:layout_constraintHorizontal_bias="1.0"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.576" />

<LinearLayout
android:id="@+id/linearLayout"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginTop="16dp"
android:gravity="center"
android:orientation="horizontal"
android:textAlignment="center"
app:layout_constraintEnd_toEndOf="@+id/btnlogin"
app:layout_constraintHorizontal_bias="0.0"
app:layout_constraintStart_toStartOf="@+id/btnlogin"
app:layout_constraintTop_toBottomOf="@+id/btnlogin">

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Dont have an Account?"
android:textColor="@color/white" />

<TextView
android:id="@+id/textViewSignUp"
 android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="SignUp"
android:textColor="@color/purple_700" />

</LinearLayout>

2.Home
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".HomeActivity">

<Button
android:id="@+id/button2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Password"
android:textSize="20sp"
android:textStyle="bold"
app:layout_constraintBottom_toBottomOf="parent"
 app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.14"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.2" />

<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Notes"
android:textSize="20sp"
android:textStyle="bold"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.141"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.098" />
</androidx.constraintlayout.widget.ConstraintLayout>

3.Notes_Details.
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@color/teal_200"
android:padding="16dp"
tools:context=".NoteDetailsActivity">

<TextView
android:id="@+id/page_title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Add New note"
android:textColor="@color/white"
android:textSize="32sp"
android:textStyle="bold" />

<ImageButton
android:id="@+id/save_note_btn"
android:layout_width="57dp"
android:layout_height="51dp"
android:layout_marginStart="87dp"
android:layout_toEndOf="@+id/page_title"
android:background="?attr/selectableItemBackgroundBorderless"
android:src="@drawable/ic_baseline_done_24"
app:tint="@color/white"
tools:ignore="SpeakableTextPresentCheck"
android:contentDescription="TODO" />

<LinearLayout
android:layout_width="382dp"
android:layout_height="508dp"

android:layout_marginVertical="26dp"
android:background="@drawable/btn_bg"
android:backgroundTint="@color/white"
android:orientation="vertical"
android:padding="16dp">

<EditText
android:id="@+id/notes_title_text"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginVertical="8dp"
android:hint="Title"
android:padding="12dp"
android:textColor="@color/black"
android:textSize="20sp"
android:textStyle="bold" />

<EditText
 android:id="@+id/notes_content_text"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginVertical="8dp"
android:gravity="top"
android:hint="Content"
android:minLines="15"

android:padding="12dp"
android:textColor="@color/black"
android:textSize="20sp" />

</LinearLayout>

</RelativeLayout>

4.Notes_activity
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@color/purple_200"
android:padding="16dp"
tools:context=".NotesActivity">
<RelativeLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/title_bar_layout">

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/page_title"
android:text="notes"
android:textSize="32sp"
android:textColor="@color/white"
android:textStyle="bold"/>
<ImageButton
android:layout_width="36dp"
android:layout_height="36dp"
android:id="@+id/menu_btn"
android:src="@drawable/ic_baseline_menu_24"
android:layout_alignParentEnd="true"
android:layout_centerVertical="true"
android:background="?attr/selectableItemBackgroundBorderless"
app:tint="@color/white"
/>

</RelativeLayout>
<androidx.recyclerview.widget.RecyclerView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_below="@+id/title_bar_layout"
android:id="@+id/recyler_view"/>
<com.google.android.material.floatingactionbutton.FloatingActionButton
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/add_note_btn"
android:backgroundTint="@color/white"
android:layout_alignParentEnd="true"
android:layout_alignParentBottom="true"
android:src="@drawable/ic_baseline_add_24"
/>

</RelativeLayout>
 5.Pass_Activity

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".PassActivity"
android:gravity="center"
android:orientation="vertical">
<TextView
android:id="@+id/password"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text=""
android:textSize="30dp"
android:layout_marginTop="200dp"/>
<Button
android:id="@+id/btn1"
 android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Generate"
android:layout_marginTop="200dp"/>

</LinearLayout>

6.Register

<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".RegisterActivity"
android:background="@drawable/bc">
<TextView
android:id="@+id/logo"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Register"
android:textColor="#F3EFEF"
android:textSize="34sp"
android:textStyle="bold"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.498"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.143" />

<EditText
android:id="@+id/inputPassord"
android:layout_width="347dp"
android:layout_height="51dp"
android:layout_marginTop="16dp"
android:background="@drawable/input_bg"
android:drawableLeft="@android:drawable/ic_lock_idle_lock"
android:drawablePadding="10dp"
android:ems="10"
android:hint="Password"
android:inputType="textVisiblePassword"
android:paddingLeft="20dp"
android:paddingTop="10dp"
android:paddingRight="10dp"
android:paddingBottom="10dp"
android:textColor="@color/white"
android:textColorHint="@color/white"
app:layout_constraintEnd_toEndOf="@+id/inputEmail"
app:layout_constraintTop_toBottomOf="@+id/inputEmail" />

<EditText
android:id="@+id/inputConformPassword"
android:layout_width="342dp"
android:layout_height="53dp"
android:layout_marginTop="12dp"
android:background="@drawable/input_bg"
android:drawableLeft="@android:drawable/ic_lock_lock"
android:drawablePadding="10dp"
android:ems="10"
android:hint="Conform Password"
android:inputType="textVisiblePassword"
android:paddingLeft="20dp"
android:paddingTop="10dp"
android:paddingRight="10dp"
android:paddingBottom="10dp"
android:textColor="@color/white"
android:textColorHint="@color/white"
app:layout_constraintEnd_toEndOf="@+id/inputPassord"
app:layout_constraintTop_toBottomOf="@+id/inputPassord" />

<EditText
android:id="@+id/inputUsername"
android:layout_width="340dp"
android:layout_height="51dp"
 android:layout_marginStart="32dp"
android:layout_marginTop="32dp"
android:layout_marginEnd="32dp"
android:background="@drawable/input_bg"
android:drawableLeft="@android:drawable/presence_invisible"
android:drawablePadding="10dp"
android:ems="10"
android:hint="Username"
android:inputType="textPersonName"
android:paddingLeft="20dp"
android:paddingTop="10dp"
android:paddingRight="10dp"
android:paddingBottom="10dp"
android:textColor="@color/white"
android:textColorHint="@color/white"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/logo" />

<EditText
android:id="@+id/inputEmail"
android:layout_width="344dp"
android:layout_height="56dp"
android:layout_marginTop="16dp"
android:background="@drawable/input_bg"
android:drawableLeft="@android:drawable/sym_action_email"
android:drawablePadding="10dp"
android:ems="10"
android:hint="Email"
android:inputType="textPersonName"
android:paddingLeft="20dp"
android:paddingTop="10dp"
android:paddingRight="10dp"
android:paddingBottom="10dp"
android:textColor="@color/white"
android:textColorHint="@color/white"
app:layout_constraintEnd_toEndOf="@+id/inputUsername"
app:layout_constraintHorizontal_bias="0.0"
app:layout_constraintStart_toStartOf="@+id/inputUsername"
app:layout_constraintTop_toBottomOf="@+id/inputUsername" />

<Button
android:id="@+id/btnRegister"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginTop="24dp"
android:background="@drawable/btn_bg"
android:text="Register"
app:layout_constraintEnd_toEndOf="@+id/inputConformPassword"
app:layout_constraintStart_toStartOf="@+id/inputConformPassword"
app:layout_constraintTop_toBottomOf="@+id/inputConformPassword"
app:rippleColor="@color/material_dynamic_neutral90" />

<TextView
android:id="@+id/alreadyHaveAccounnt"
android:layout_width="177dp"
android:layout_height="31dp"
android:shadowColor="@color/black"
android:text="Already Have an Account"
 android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.807"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/btnRegister"
app:layout_constraintVertical_bias="0.081" />

</androidx.constraintlayout.widget.ConstraintLayout>

6.Recycler_Notes

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="12dp"
android:layout_marginVertical="8dp"
android:backgroundTint="@color/white"
android:background="@drawable/btn_bg">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
 android:id="@+id/note_title_text_view"
android:text="note title"
android:textColor="@color/black"
android:textSize="18sp"
android:layout_marginVertical="4dp"
/>
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/note_content_text_view"
android:text="This can be note content that can be long"
android:maxLines="2"
android:ellipsize="end"
android:textSize="17sp"
android:layout_marginVertical="4dp"
/>
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="note title"
android:id="@+id/note_timestamp_text_view"
android:textSize="12sp"
android:gravity="right"
android:layout_marginVertical="4dp"
/>

</LinearLayout>
 REFERENCES
https://www.crio.do/projects/java-android-notes-password-manager/

https://www.youtube.com/