NOTES APP IN ANDROID
A Summer Internship Project Report
ON
Submitted in Partial Fulfillment of the Requirements
For the award of the Degree of
Bachelor of Technology
in
Information Technology (IT)
By
Boorla Naganishitha (22311A1269)
Moturi Vijay Ram Chandra (22311A1270)
Manasa Pasupunuri (22311A1272)
Under the Guidance / Supervision of
R.K Reddy(Assistant professor)
Department of Information Technology
Sreenidhi Institute of Science & Technology (Autonomous)
2022-2023
Yamnampet, Ghatkesar, R.R. District, Hyderabad - 501301
Affiliated to Jawaharlal Nehru Technology University
Hyderabad - 500085
DEPARTMENT OF INFORMATION TECHNOLOGY
1
SREENIDHI INSTITUTE OF SCIENCE & TECHNOLOGY
(AUTONOMOUS)
CERTIFICATE
This is to certify that the Summer Internship Project entitled “NOTES APP IN
ANDROID” submitted by, Boorla Naganishitha (22311A1269), Moturi Vijay Ram
Chandra (22311A1270), Manasa Pasupunuri (22311A1272) towards partial
fulfillment for the award of Bachelor’s Degree in Information Technology from
Sreenidhi Institute of Science & Technology, Ghatkesar, Hyderabad, is a record of
bonafide work done by him. The results embodied in the work are not submitted to any
other University or Institute for award of any degree or diploma.
R.K REDDY Dr. SUNIL BHUTADA
Assistant Professor Professor & HOD IT
2
DECLARATION
This is to certify that the work reported in the present Summer Internship Project titled
“NOTES APP IN ANDROID” is a record work done by my team in the Department
of Information Technology, Sreenidhi Institute of Science and Technology,
Yamnampet, Ghatkesar. The report is based on the project work done entirely by our
team and not copied from any other source.
3
ACKNOWLEDGMENT
I convey my sincere thanks Dr.T.Ch. SIVA REDDY, Principal, Sreenidhi Institute of
Science and Technology, Ghatkesar for providing resources to complete this seminar.
I am very thankful to Dr. SUNIL BHUTADA, Head of IT Department, Sreenidhi
Institute of Science and Technology, Ghatkesar for providing an initiative to this project
and giving valuable timely suggestions over our seminar work and for their kind co-
operation in the completion of the seminar.
I convey my sincere thanks to R.K Reddy, Professor and all the faculties of IT
Department, Sreenidhi Institute of Science and Technology, for their continuous help,
co-operation, and support to complete this project.
Finally, I extend my sense of gratitude to almighty, my parents, all my friends, teaching
and non-teaching staff, who directly or indirectly helped me in this endeavor.
4
NOTES APP IN ANDROID
Abstract
Taking a note is the process of capturing information in a source or event. This usually takes type of writing,
jotting, wording, scanning, labelling and outline. Many apps have their own unique features, storage, editing,
and sharing capabilities, and so on for the user to see which note-taking app will work best for their needs.
Notes apps (also called note-taking apps) allow students to save all the notes and essentials digital information.
Users can also scan the notes and attach multimedia to their notes to enrich the description and context.
Android Notes app is an Android-based application that is built in the Java. A completely native app, using
the latest features of the Android platform to provide the best user experience. It can be used to store important
notes, daily activities, photos etc.
The method of recording information from a source or event is called taking a note. Writing, note- taking,
sentence structure scanning, categorizing, and outlining are usually needed for this. A user may choose the
note-taking software that best suits their needs from a number of options that each provide different operation,
storage, editing, and sharing capabilities, among other things. Students may store all of their notes and
important digital information with note-taking apps.
In order to improve the description and context, users may also scan their notes and add multimedia
attachments. The Java-built Android Notes app is an example of an Android application. An completely native
program that improves user experience by using the most recent features that are available on the Android
platform.
Keywords: Android, Notes, Scanlibrary, Scanner, Room Database, Sqlite, Java.
5
INDEX
1.INTRODUCTION 7
1.1 Scope 7
1.2 Existing System 7
1.3 Proposed System 7
2.Expermental Setup 8
2.1Hardware and Software Requirements 8
3. SYSTEM DESIGN 9
3.1 Architecture Design 9
3.2 Architecture Algorithm 9
3.3 UML Diagrams 10
3.3.1 Use Case Diagrams 11
4.SYSTEM IMPLEMENTATION 12-20
5.OUTPUT SCREENS 20-21
6.INTERNSHIP FEEDBACK 22
6.1 Challenges faced 22
7. CONCLUSIONS AND FUTURE SCOPE 22
REFERENCES 23
6
1. INTRODUCTION
Android Notes Application aims to address the daily problem of taking notes at appropriate times when the
event is fast paced and you do not have time to pull out your pen and paper. Taking a note is the process of
taking information from a source or event. This often takes the form of writing, snapping, abbreviating,
scanning, labelling, clarifying, and defining. Users may type on mobile devices just like they would on
paper with note-taking apps. This is an Android-based application which is developed in Java. Completely
native application, using the latest features of the Android platform to provide the best user experience. It
can be used to store important notes, daily activities, photos etc. It uses device’s local storage as a backend
storage support to store user data and for scanning purpose, opencv based opensource scanlibrary is used.
The notes app is an application, built for storing information and notes that are important to the person. It
also includes creation, storage, sharing, retrieval and editing notes. This app can be used to store all notes
and information digitally and helps to complete the written process digitally to save a lot of time.
1.1 Scope
The scope for a notes app in Android can include features such as basic note-taking functionalities, rich
media support, organization and categorization options, sync and cloud integration, search functionality,
reminders, security and privacy measures, backup and restore capabilities, collaboration features,
customization options, widgets, integration with system features, analytics, accessibility, offline mode, task
management, export and print functionalities, and feedback and support systems. The scope can be tailored
based on the target audience and development goals.
1.2 Existing System
Existing System Analysis for Android Notes App Project:Many note-taking apps lack the seamless
integration of essential functionalities, such as the ability to categorize notes effectively or employ advanced
search mechanisms for quick retrieval. Furthermore, some applications exhibit performance issues,
impacting the user experience, particularly as the volume of stored notes increases.
1.3Proposed System
Proposed System for Android Notes App Project:
1. Intuitive User Interface:
The proposed system focuses on delivering an intuitive and visually appealing user interface, ensuring ease
of use for individuals of varying technological proficiencies.
2. Rich Text Formatting:
To empower users in expressing their ideas effectively, the app will support rich text formatting options.
3. Advanced Organization and Tagging:
The proposed system will introduce advanced organizational features, including intuitive categorization
through tags and folders
4. Robust Search Functionality:
A powerful search engine will be implemented, enabling users to quickly retrieve specific notes based on
keywords or tags.
7
2.EXPERIMENTAL SETUP
For this project, we have used Android Studio, Java SDK and Room Database for storage support to store
the user data. Scanlibrary is used basically to detect the edges of the paper while scanning the notes. Given
below is the short information of everything we have used in the project. Android Studio: According to
[10], Android Studio is Google's official integrated development platform (IDE) Android operating system,
built on JetBrains' IntelliJ IDEA software and built specifically Android upgrade. Available for download
on Windows, macOS and Linux based applications systems or as a subscriptionbased service by 2020. It
replaces Eclipse Android Development Tools (ADT) as the main IDE for Android application development.
Java SDK: Java SDK stands for Java Software Development Kit. It is a software development kit for
developing software in Java. It is one of three technology packages used by Java, namely JVM, JRE and
JDK. JDK contains a set of development tools that help to develop java-based software. There are several
versions, but Java 8 is the most widely used. SDK tools include libraries, combinations, debugger,
processes, API, code samples, guidelines etc. SDKs are varied; has a different kind of platform.
SQLite Database: [9], SQLite is a type of database engine. It is a lightweight database that enables users
to interface with a relational database. SQLite stores a database in a single file, which separates it from other
database engines. This allows for a high level of accessibility: duplicating a database is as simple as copying
the file that stores the data, and sharing a database can be as simple as sending an
email attachment. SQLite is a significantly lighter version of SQL database, and most SQL operations do
not run-on SQLite database.
2.1 HARDWARE AND SOFWARE REQUIREMENTS
8
3.SYSTEM DESIGN
Systems design is the process of defining the architecture, components, modules, interfaces, and data for a
system to satisfy specified requirements. One could see it as the application of systems theory to product
development. Object-oriented analysis and design methods are becoming the most widely used methods for
computer systems design.
3.1 Architectural Design
Application Flowchart.
Architecture Algorithm:
1) Open application
2) Application lock if enabled
3) Home Screen
a. View already added notes
1. Export/Share
b. Create new note
1. Export/Share
4) Navigation Sidebar
a. Settings b. Recycle Bin
1. Restore note
2. Delete note
c. Home Screen
9
UML Diagrams for our application are as follows:
3.3.1 Use Case Diagrams
Fig 3.1 Room database model.
Fig 3.2 DFD Level 0
10
Fig 3.3 DFD Level 1
Use Case Diagram
Fig 3.4 : Use Case Diagram
11
In UML, use-case diagrams model the behavior of a system and help to capture the requirements of
the system. Use-case diagrams describe the high-level functions and scope of a system. These
diagrams also identify the interactions between the system and its actors.
4.SYSTEM IMPLEMENTATION
Step 1: Create a New Project
To create a new project in Android Studio please refer to How to Create/Start a New Project in Android
Studio. Note that select Java as the programming language.
Step 2: Working with the AndroidManifest.xml file
Add the user permissions for reading and write the file from storage. Also, in order to register the widget,
we have to create a broadcast receiver with an intent filter.
CODE:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.notes">
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.Notes">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
12
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<!-- To register a widget, you create a broadcast receiver with
an intent filter for the android.appwidget.action.APPWIDGET_UPDATE action-->
<receiver
android:name=".AppWidget"
android:label="StickyNotes">
<intent-filter>
<action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
</intent-filter>
<!-- This metadata contains the configuration of your widget,
the resource attribute contains the layout of your widget as
it will be seen in the list of widgets -->
<meta-data
android:name="android.appwidget.provider"
android:resource="@xml/new_app_widget_info" />
</receiver>
</application>
</manifest>
Step 3: Creating a Widget
Follow the steps mentioned in this article Create a Basic Widget of an Android App to add the
Widget to your project. The file new_app_widget_info.xml contains code that determines the look
of our widget as it would appear in the Widgets list.
Step 4: Working with the AppWidget Class
This class will be formed in the previous step. Go to the AppWidget.java file and refer to the
following code. Below is the code for the AppWidget.java file. Comments are added inside the
code to understand the code in more detail.
13
CODE:
import android.app.PendingIntent;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.Context;
import android.content.Intent;
import android.widget.RemoteViews;
// Implementation of App Widget functionality
public class AppWidget extends AppWidgetProvider {
// Create an Intent to launch activity
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
// Perform this loop procedure for each App Widget
// that belongs to this provider
for (int appWidgetId : appWidgetIds) {
// Create an Intent to launch MainActivity
Intent launchActivity = new Intent(context, MainActivity.class);
// Attaching a Pending Intent
// to trigger it when
// application is not alive
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, launchActivity, 0);
// Get the layout for the App Widget and attach
// an on-click listener to the button
RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.new_app_widget);
remoteViews.setOnClickPendingIntent(R.id.appwidget_text, pendingIntent);
// Tell the AppWidgetManager to perform an
14
// update on the current app widget
appWidgetManager.updateAppWidget(appWidgetId, remoteViews);
Step 5: Creating the StickyNote Class
This is a helper class that provides the functionality of saving, updating, and retrieving the contents to and
from the file. Go to the StickyNote .java file and refer to the following code. Below is the code for
the StickyNote .java file. Comments are added inside the code to understand the code in more detail.
CODE:
import android.content.Context;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import static android.content.Context.MODE_PRIVATE;
class StickyNote {
// this function will return
// the content from the text
// file(if any)
String getStick(Context context) {
// get the file from path
File fileEvents = new File(context.getFilesDir().getPath() + "/gfg.txt");
// create a StringBuilder to store the text from file
StringBuilder text = new StringBuilder();
try {
15
// use the BufferedReader
// to Read the file
// efficiently
BufferedReader br = new BufferedReader(new FileReader(fileEvents));
String line;
// read a single line at a time
// append newline character after each line
while ((line = br.readLine()) != null) {
text.append(line);
text.append('\n');
// close the BufferedReader
br.close();
} catch (IOException e) {
e.printStackTrace();
// finally return the
// string i.e. the retrieved data
// from file
return text.toString();
// this function saves the new
// content in the file if it
// exists or will create a new one
void setStick(String textToBeSaved, Context context) {
16
String text = textToBeSaved;
// create the FileOutputStream
// to efficiently write the file
FileOutputStream fos = null;
try {
// get the file from storage
fos = context.getApplicationContext().openFileOutput("gfg.txt", MODE_PRIVATE);
// write to the file at once
fos.write(text.getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
17
Step 6: Working with the MainActivity.java file
Go to the MainActivity.java file and refer to the following code. Below is the code for
the MainActivity.java file. Comments are added inside the code to understand the code
in more detail.
CODE:
import android.appwidget.AppWidgetManager;
import android.content.ComponentName;
import android.widget.EditText;
import android.widget.RemoteViews;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
EditText mEditText;
// creating a new note
StickyNote note = new StickyNote();
@Override
protected void
onCreate(android.os.Bundle savedInstanceState) {
setContentView(R.layout.activity_main);
super.onCreate(savedInstanceState);
// getting the reference of the EditText
mEditText = findViewById(R.id.editText);
// retrieve the text from the saved file in
// memory(if any) and set it to the edittext
mEditText.setText(note.getStick(this));
}
// function to update the
// Widget(Sticky Note) every time
// user saves the note
public void updateWidget() {
// the AppWidgetManager helps
// us to manage all the
// widgets from this app
AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(this);
// the RemoteViews class allows us to inflate a
// layout resource file hierarchy and provides some
// basic operations for modifying the content of the
// inflated hierarchy
RemoteViews remoteViews = new RemoteViews(this.getPackageName(), R.layout.new_app_widget);
// by using ComponentName class we can get specific
// application component and to identify the
// component we pass the package name and the class
18
// name inside of that package
ComponentName thisWidget = new ComponentName(this, AppWidget.class);
// update the text of the textview of the widget
remoteViews.setTextViewText(R.id.appwidget_text, mEditText.getText().toString());
// finally us the AppWidgetManager instance to
// update all the widgets
appWidgetManager.updateAppWidget(thisWidget, remoteViews);
}
// this function saves
// the current status
// of the EditText
public void saveButton(android.view.View v) {
// update the content of file stored in the memory
note.setStick(mEditText.getText().toString(), this);
updateWidget();
Toast.makeText(this, "Updated Successfully!!", Toast.LENGTH_SHORT).show();
}
}
Step 7: Layout file of our Widget
Since we only want our widget to hold the text, we just add the TextView in the layout
resource file which would be updated from time to time.
CODE:
<FrameLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/widgetLayout"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#FDD835"
android:orientation="horizontal"
android:padding="8dp">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<TextView
android:id="@+id/appwidget_text"
android:layout_width="wrap_content"
19
android:layout_height="wrap_content"
android:text="Text"
android:textColor="#ffffff"
android:textSize="20sp"
tools:layout_editor_absoluteX="1dp"
tools:layout_editor_absoluteY="1dp" />
</LinearLayout>
</FrameLayout>
5.OUTPUT SCREENS
Output Screens of various functionalities in our application are shown over here along with the
description.
20
6.INTERNSHIP FEEDBACK
21
6.1 CHALLENGES FACED
It was a good experience performing all the lab activities and also refer ing the keen power point
presentations provided .Also it was a new experience for us to enhance your skills by using all the
applications provided in the internship. we have got hands-on experience to use each and every tool in
AWS platform by performing various lab activities. The guided labs were the building
blocks which are to be learnt to perform the challenging labs which were really challenging and compact.
7.CONCLUSION AND FUTURE SCOPE
CONCLUSION
From the research we understood that, currently, the popularization of the internet has led to a decline in
revenue in the paper industry, but the pen and pencil industry’s revenue has grown in recent years. These
conflicting numbers are inconclusive in regards to whether or not students are abandoning paper-based
notetaking. Many students are taking advantage of the electronics in the classroom. In conclusion, major
benefits of the project are:
No reach limitations, it provides a user-friendly GUI which results in retaining of users.
Media attachment support and inbuilt scanner to scan notes.
Flexibility for users to generate various files of notes such as .png, .pdf, .txt
Inbuilt Passcode and biometric security.
Lightweight SQLite database.
FUTURE SCOPE
We should expect to see an increase in note-taking gadgets in the classroom in various forms as note-taking
technology grows more sophisticated with the addition of scribe pens and styli. We can see the possibility
for transferring complicated material, such as handwritten text or drawings, digitally, with the rise of online,
hybrid, and blended learning courses. Tools outside of the notetaking realm are also taking up note-taking
features. For example, eBooks are now using notetaking features such as annotating, highlighting, and
underlining to mimic the experience of reading a physical book.
REFERENCES
[1] https://academictechnologies.it.miami.edu/explore-technologies/technology-summaries/note-
takingapplications/index.html
22
[2] I. Culjak, D. Abram, T. Pribanic, H. Dzapo and M. Cifrek, "A brief introduction to OpenCV," 2012 Proceedings of
the 35th International Convention MIPRO, 2012, pp. 1725-1730.
[3] Xie, Guobo and Wen Lu. “Image Edge Detection Based On Opencv.” International Journal of Electronics and
Electrical Engineering 1 (2013): 104-106.
[4] Ansari, Mohd & Kurchaniya, Diksha & Dixit, Manish. (2017). A Comprehensive Analysis of Image Edge Detection
Techniques. International Journal of Multimedia and Ubiquitous Engineering. 12. 1-12. 10.14257/ijmue.2017.12.11.01.
[5] P. Ganesan and G. Sajiv, "A comprehensive study of edge detection for image processing applications," 2017
International Conference on Innovations in Information, Embedded and Communication Systems (ICIIECS), 2017, pp.
1-6, doi: 10.1109/ICIIECS.2017.8275968.
[6]https://medium.com/@hrishitamavani/step-by-step-guide-to-build-document-scanner-android-appfa774ad3772e
[7]https://github.com/jhansireddy/AndroidScannerDemo
[8]https://developer.android.com/training/data-storage/room
[9] https://developer.android.com/docs
23
