DEVELOPMENT OF AN REACT-NATIVE BASED

APPLICATION “PIC ME”

A project report submitted in partial fulfilment of the requirements for the

degree of Master of Computer Application

Submitted by
Name of the Candidate Roll Number
Argho Banerjee 16901016033
Debarti Sett 16901016031

Under the guidance of

Mr. Sovan Bhattachariya

(React-Native App Developer of Esolz)

Submitted to

ACADEMY OF TECHNOLOGY
Aedconagar, Hooghly-712121, West Bengal

Department of MCA
Academy of Technology, Aedconagar, Hooghly-712121

1
 CERTIFICATE

This is certified that this project entitled “Pic Me” has been successfully completed under
supervision and guidance of Mr. Sovan Bhattachariya and done by Argho Banerjee and
Debarti Sett in partial fulfilment of the requirement for the degree of MASTER OF
COMPUTER APPLICATION from Maulana Abul Kalam Azad University of Technology,
West Bengal.

------------------------------------
Mr. Sovan Bhattachariya
(HOD of MCA department)

2
 ACKNOWLEDGEMENTS

The project report on “Smart Academics” is outcome of guidance, moral support and
devotion bestowed on us throughout our work. For this we acknowledge and express our
profound sense of gratitude and thanks to everybody who have been a source of inspiration
during the project preparation.

First and foremost we offer our sincere phrases of thanks with innate humility to our Project
Guide and Head of the department of MCA of Academy of Technology Prof. Krishna
Bhowal for providing constant supervision as well as for providing necessary information
regarding project.

Date:
Place: Academy of Technology, ------------------------------------
Adisaptagram, Aedconagar ( Dipayan Palit )

-----------------------------------
( Moumita Roy )

------------------------------------
( Subham Debnath )

------------------------------------
(Sucheta Saha)

3
 CONTENTS
Chapter Name Page No
1. Introduction............................................................................5
Objective.................................................................................5
Scope......................................................................................5
Methodologies.........................................................................6
2. System Analysis.......................................................................7
Feasibility Study.....................................................................7
Project Planning and chart (Gantt Chart)................................7
Software Model.......................................................................9
Software requirement Specification.........................................10
System Requirement................................................................11
Function Specification.............................................................11
3. System Design............................................................................12
Data Flow Diagram..................................................................12
Entity Relationship Diagram....................................................15
Use-case Diagram.....................................................................18
Snapshots.................................................................................19
4. Implementation............................................................................25
Sample Code.............................................................................26
5. Testing..........................................................................................35
Introduction..............................................................................35
Objective of Testing..................................................................35
Test Cases.................................................................................35
Testing Step..............................................................................35
Database security Measures......................................................37
System Security Measures........................................................37
Limitation..................................................................................37
6. Summary.......................................................................................38
Conclusion.................................................................................38
Future Scope and Further Enhancements...................................38
7. References......................................................................................39

4
CHAPTER 1

Introduction:

In recent times, we all are so busy with our daily schedule and always we want to save our
time with the help of some advanced technology. Pic Me app is an Internet based Mobile
Application that helps you to order food from any location and with in a specified time period
the food will be delivered to you and if cupon code applied then the cost will be lesser than
the actual.

Objective:

The objective of this project is to design a app that can be installed to a ios system and also to
a android system. Our busy life will need the power of technology to overcome the limitation
of time and distance. Pic Me application is extremely user-friendly. In this application, User
can login with google mail or facebbok, can add food to cart or wishlist, User can order food
from any location, can apply promo code for getting discount and with in a specified time the
food will be delivered to customer.

Scope:

 Login can also be done via google or facebook.

 List of foods will be shown.
 Promo code can be applied for getting discount.
 Add to cart and add to wishlist also be done.
 Food can be ordered from any location.
 Food will be delivered with in a specified time.

5
Methodologies:

Descriptive research will be used .Descriptive research answers the questions who, what,
where, when and how the conditions is of the situation under study. In this research, this
applies as this will determine the perceptions of both teacher and students towards
mobile. The results will be the basis for future development of mobile teaching and
learning application.
Analysis is the procedure that identifies, describes and evaluates the candidate system and
selects the best possible action for the job. Once after identifying the preliminary area of
application, to examine it more rigorously we have conducted a FEASIBILITY STUDY.
By the initial investigation, we have identified the need, problems and requirements. So
our next step was to determine exactly what the proposed system is to do by defining its
expected performance .This kind of work can be carried out in the feasibility study is not
to solve the problem but to acquire a sense of its scope. It is more of research on the
system. Once it has been determined that a project is feasible, one can go ahead and
prepare the project specification which finalizes the project requirements. During the
study, the problem definition is crystallized and aspects of the problem to be included in
the system are determined. Consequently, costs and benefits are estimated with greater
accuracy at this stage. The result of the feasibility study is a formal proposal.

6
CHAPTER 2:

System Analysis:

System Analysis is a process of gathering and interpreting facts, diagnosing problems and
the information to recommend improvements on the system. It is a problem solving
activity that requires intensive communication between the system users and system
developers. System analysis or study is an important phase of any system development
process. The system studies the minutest detail and gets analyzed. The system analyst
plays the role of the interrogator and dwells deep into the working of the present system.
The system is viewed as a whole and the input to the system are identified. The outputs
from the organization are traced to the various processes. System analysis is concerned
with becoming aware of the problem, identifying the relevant and Decisional variables,
analysis and synthesizing the various factors and determining an optional or at least a
satisfactory solution or program of action.

Feasibility Study:

Feasibility Study is made to see if the project on completion will serve the purpose the
organisation for the amount of work.
A feasibility study is used to determine the viability of an idea, such as ensuring a project
is legally and technically feasible as well as economically justifiable.
The document provide the feasibility of the project that is being designed and list various
area that were considered very carefully during the feasibility study of this project such as
Technical, Economical and operational feasibilities.

Project planning and chart:

Project planning includes description of the project task, activity and function,
dependencies, resource requirements and detail schedules. Project planning involves
estimating how much time, effort, money and resource will be required build a specific
software system. A Software Process model is simplified abstract representation of a
software process, which is presented from perspective. Planning prepares a framework
that makes a reasonable estimate of the project. To accomplish it, software development
model are used.

7
Gantt chart Table:

Gantt chart Diagram

8
Software Model:

This Document plays a vital role in the development life cycle (SDLC) as it describes the
complete requirement of the system. It is meant for use by the developers and will be the
basic during testing phase. Any changes made to the requirements in the future will have to
go through formal change approval process.
The Waterfall Model was first Process Model to be introduced. It is also referred to as a
linear-sequential life cycle model. It is very simple to understand and use.

Waterfall Model Design:

Waterfall approach was first SDLC Model to be used widely in Software Engineering to
ensure success of the project. In “Waterfall” approach, the whole process of software
development is divided into separate phases. In Waterfall model, typically, the outcome of
one phase acts as the input for the next phase sequentially. Following is a diagrammatic
representation of different phases of waterfall model.

All these phases are cascaded to each other in which progress is seen as flowing steadily
downwards through the phases. The next phase is started only after the defined set of goals
are achieved for previous phase and it is signed off, so the name “Waterfall Model”. In this
phases do not overlap.

9
Waterfall Model Application:

Every software developer is different and requires a suitable SDLC approach to be followed
based on the internal and external factors. Some situations where the use of Waterfall model
is most appropriates are:
 Requirements are very well documented, clear and fixed.
 Product definition is stable.
 Technology is understood.
 There are no ambiguous requirements.
 The project is short

Advantages and Disadvantages:

The advantage of this model is that there is a working of the system at a very early stage of
development which makes it easier to find functional or design flaws. Finding issues at an
early stage of development enables to take corrective measure in a limited budget.
This disadvantage with this SDLC model is that it is applicable only to large and bulky
software development projects. This is because it is hard to break small software system
further small serviceable increments /modules.

Software Requirement Specification:

Software Requirement Specification (SRS) is the starting point of the development

activity.SRS is a complete description of the behaviour of a system to be developed. It
includes a set of causes that describe all the instructions the user will have with the software
.in addition to use cases, the SRS also contains non-functional requirements. Non-functional
requirements are required which impose constraints on the design or implementation.

Functional Requirements:

A functional requirement provides a clear view on the input. Information they will be
processed and output of the system. These requirements are also describing the interactions
between system and its environments independent of its implementation.
Some of the functional requirements of this project are:
 It must fast updates on the data in the database.
 It should allow the user to view the study material.
 It should allows the user to upload and download file
 It must be able to provide tables to store data and for retrieving the stored data.
 Administrator should be provided all the facilities to update tables and to view the
generated table.

10
Non-Functional Requirements:

A non-functional requirement is usually some form of constraint or restriction that must be

considered when designing the solution. These requirements describe user-visible aspects of
the system that are not directly to functionally of the system. Some of the non-functional
requirements this project is as follows:
 Portability
 Reliability
 Efficiency

SYSTEM REQUIREMENT:

Software Requirements:

 ANDROID [Platform]
 XML [Front End]
 JAVA[Back End]
 PHP [Server Site]
 MySQL [Database]
 Apache [Web Server]

Hardware Requirements:

 HDD:500GB(Machine)
 RAM:4GB(Mobile/Machine)
 Processor:i3 or more(Machine) and 2.0GHz(Mobile)

Functional Specification:

Different functions which will be performed by this system can be classified into two basic
modules. Each of this can do a few functions as:
Modules for Teacher:
Registration, Login, File Upload, File Download, Take attendance, Logout
Modules for Student:
Registration, Login, File Download , Show Attendance details,Logout

11
CHAPTER 3:

System Design:

System design involves the analysis, design and configuration of the necessary hardware and
software components to support the solution’s architecture. It purposes is to create a technical
solution of the problem.

DATA FLOW DIAGRAM (DFD):

The DFD (also known as the bubble chart or work flow diagram) is a simple graphical
notation that can be used to represent a system in terms of the input data to the system,
various processing carried out on these data, and the output data generated by the system.

Objectives of DFD:

 It represents system data in a hierarchical manner and with required levels of detail.
 It depicts processes according to defined user requirements and software scope.
 It depicts flow of data from one or more processes to another.
 It provides an overview of the transformations that occur in the input data within the
system in order to produce an output.

Symbols used for constructing DFD:

 External entity symbol: A rectangle represents an external entity i.e. source or

destination of data within the system. Each external entity is identified with a
meaningful and unique name.

 Process Symbols: A process symbol is represented using circle. It shows a

transformation or manipulation of data within the system.

12
  Data-Flow Symbol: A directed arrow or arc is used as a data-flow symbol. It
represents the movement of data from its source to destination within the system.

 Data store symbol: Open boxes are used to represent data store. It indicates the
place for storing information within the system.

 Output symbol: A rectangle with a cut at top right corner is used as output symbols.
This box represents data production during human-computer interaction.

Steps to construct Data Flow Diagram:

Four steps are generally used to construct a DFD.
 Process should be named and referred for easy reference. Each name should be
representative of the reference.
 The destination of flow is from top to bottom and from left to right.
 When a process is distributed into lower level details there are numbered.
 The names of data stores, sources and destinations are written in capital letters.

Fig: Level-0 DFD

13
 Fig: Level-1 DFD

Fig: Level-0.1.1 DFD

14
ENTITY RELATIONSHIP DIAGRAM:

In software engineering, Entity Relationship Data Model is a high level data model. It is
based on a perception of a real world that consists of a collection of basic objects, such as a
entities and relationships among these objects.
The overall logical structure (schema) of a database can be expressed graphically by a
diagram, known as E-R diagram. They are simple and clear to understand the database
design.
The three schema approach to software engineering uses three levels of ER models that may
be developed.

Conceptual data model:

The conceptual ER model normally defines master reference data entities that are commonly
used by the organization. Developing an enterprise-wide conceptual ER model is useful to
support documenting the data architecture for an organization. A conceptual ER model may
be used as the foundation for one or more logical data models. The purpose of conceptual ER
model is then to establish structural metadata commonality for the master data entries
between the set of logical ER models. The conceptual data model may be used to form
commonality relationship between ER models as a basis for data model integration.

Logical data model:

The logical ER model contains more detail than the conceptual ER model. In addition to
master data entities, operational and transactional data entities are now defined. The details of
each data entity are developed and the relationships between these data entities are
established. The logical ER model is however developed independent of technology into
which it can be implemented.

Physical data model:

One or more physical ER models may be developed from each logical ER model. In physical
ER model is exactly developed to be instantiated as a database. Therefore, each physical ER
model must contain enough detail to produce a database and each physical ER model is
technology dependent since each database management system is somewhat different.
The physical model is normally instantiated in the structural metadata of a database
management system as relational database objects such as database tables, database indexes
such as key indexes and database constraints such as foreign key constraint or a commonality
constraint. The ER model is also normally and to design modification to the relational
database objects and to maintain the structural metadata of database.

15
Components of Entity-relationship Diagram:

 Rectangle: Represents entity sets.

 Ellipse: Represents attributes.

 Diamond: Represents relationship sets.

 Lines: Links attributes to the entity sets and entity sets to the relationship sets.

 Double Ellipse: represents multivalued attributes.

16
Entity-relationship Diagram:

17
USE CASE DIAGRAM:

A use case diagram at its simplest is a representation of a user's interaction with the system
that shows the relationship between the user and the different use cases in which the user is
involved. A use case diagram can identify the different types of users of a system and the
different use cases and will often be accompanied by other types of diagrams as well.
Use case diagrams are used to gather the requirements of a system including internal and
external influences. These requirements are mostly design requirements. Hence, when a
system is analyzed to gather its functionalities, use cases are prepared and actors are
identified.
When the initial task is complete, use case diagrams are modelled to present the outside
view.
In brief, the purposes of use case diagrams can be said to be as follows
 Used to gather the requirements of a system.
 Used to get an outside view of a system.
 Identify the external and internal factors influencing the system.
 Shows the interactions among the requirements are actors.

How to Draw a Use Case Diagram?

Use case diagrams are considered for high level requirement analysis of a system. When the
requirements of a system are analyzed, the functionalities are captured in use cases.
We can say that use cases are nothing but the system functionalities written in an organized
manner. The second thing which is relevant to use cases are the actors. Actors can be
defined as something that interacts with the system.
Actors can be a human user, some internal applications, or may be some external
applications. When we are planning to draw a use case diagram, we should have the
following items identified.
 Functionalities to be represented as use case
 Actors
 Relationships among the use cases and actors.
Use case diagrams are drawn to capture the functional requirements of a system. After
identifying the above items, we have to use the following guidelines to draw an efficient use
case diagram
 The name of a use case is very important. The name should be chosen in such a way
so that it can identify the functionalities performed.
 Give a suitable name for actors.
 Show relationships and dependencies clearly in the diagram.

18
 Do not try to include all types of relationships, as the main purpose of the diagram is
to identify the requirements.
 Use notes whenever required to clarify some important points.

Fig: USE CASE DIAGRAM OF SMART ACADEMICS APPLICATION

19
SNAPSHOT:
Login Page:

Teacher Database Table:

20
21
22
23
Notification:

24
CHAPTER 4:
Implementation:
XML:
XML is Extensive Markup Language. Extensible Markup Language (XML) is a markup
language that defies a set of rules for encoding documents in a format that is both human-
readable and machine-readable. The design goals of XML emphasize simplicity, generality
and usability over the Internet. It is a textual data format with strong support via Unicode for
the languages of the world. It is used for designing the layouts of each activity of the
application.

JAVA:
Java is an Object Oriented Programming language used for making Desktop applications,
WEB Application and Mobile Applications. Android relies heavily on the JAVA
fundamentals. The Android SDK includes many standard Java libraries as well as special
Android Libraries that will help you develop awesome Android Application.

PHP:
PHP(Hypertext Pre-processor) is a widely-used open source general-purpose scripting
language scripting that is especially suited for web development and can be embedded into
HTML.PHP is used at backend in order to send the requests and receive the responses from
the Web Server.

SQLite:
SQLite is a relational database management system contained in a C programming library. In
contrast to other database management systems, SQLite is not a separate process that is a
popular choice as embedded database for local/client storage in application software such as
web browsers. SQLite is used in application as local database of each Android device.

MySQLi:
The MySQLi Extension (MySQL Improved) is a relational database driver used in
the PHP scripting language to provide an interface with MySQL databases.
There are three main API options when considering connecting to a MySQL database server:

 PHP's MySQL Extension

 PHP's MySQLi Extension
 PHP Data Objects (PDO)

MySQLi is an improved version of the older PHP MySQL driver, offering various benefits.

25
SAMPLE CODE OF THIS PROJECT:

XML CODE OF TEACHER LOGIN:

<?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:orientation="vertical"
android:weightSum="1">
<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:layout_marginTop="20dp"
android:text="Teacher"
android:textAppearance="@style/TextAppearance.AppCompat.Display1"
android:textColor="#01579B"
android:textSize="30dp"
android:textStyle="bold" />
<android.support.v7.widget.CardView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_below="@+id/textView2"
app:cardCornerRadius="25dp"
android:layout_marginRight="30dp"
android:layout_marginLeft="30dp"
android:layout_marginTop="60dp"
app:cardElevation="10dp"
android:id="@+id/cardView_teach_login"
android:layout_centerHorizontal="true">
<RelativeLayout
android:layout_width="match_parent"
android:layout_height="match_parent">
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="vertical"
android:paddingTop="30dp">
<EditText

26
 android:id="@+id/et_username"
android:layout_width="345dp"
android:layout_height="wrap_content"
android:ems="10"
android:hint="Username"
android:inputType="textPersonName"
android:drawableLeft="@drawable/ic_action_user"
android:layout_above="@+id/et_pass"
android:layout_centerHorizontal="true"
android:layout_marginBottom="11dp"
android:text="sucheta"/>
<EditText
android:id="@+id/et_pass"
android:layout_width="345dp"
android:layout_height="wrap_content"
android:layout_alignStart="@+id/et_username"
android:layout_centerVertical="true"
android:ems="10"
android:hint="Password" android:drawableLeft="@drawable/ic_action_name"
android:inputType="textPassword"
android:layout_alignLeft="@+id/et_username" android:text="suchetasaha" />
<CheckBox
android:id="@+id/cb_showpswdteacher"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/et_pass"
android:text="Show Password"
android:textColor="@color/colorPrimary"
android:textStyle="bold"
android:layout_alignLeft="@+id/et_pass" />
<Button
android:id="@+id/btn_login"
android:layout_width="fill_parent"
android:layout_height="40dp"
android:layout_marginLeft="80dp"
android:layout_marginRight="80dp"
android:layout_marginTop="22dp"
android:layout_marginBottom="22dp"
android:layout_below="@+id/cb_rememberpswdteacher"
android:background="@drawable/roundshape"
android:textColor="#424242"
android:text="Login"
android:layout_alignRight="@+id/et_pass" />
</LinearLayout>
27
 </RelativeLayout>
</android.support.v7.widget.CardView>
<android.support.v7.widget.CardView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_below="@+id/textView2"
app:cardCornerRadius="25dp"
android:layout_marginRight="80dp"
android:layout_marginLeft="200dp"
android:layout_marginTop="15dp"
app:cardElevation="10dp"
android:id="@+id/cardView_teach_image"
android:layout_centerHorizontal="true">
<RelativeLayout
android:layout_width="match_parent"
android:layout_height="wrap_content">
<ImageButton
android:id="@+id/user_profile_photo"
android:layout_width="80dp"
android:layout_height="80dp"
android:background="@drawable/myuser1"
android:elevation="4dp"
android:layout_centerHorizontal="true"
android:layout_marginLeft="120dp"
/>
</RelativeLayout>
</android.support.v7.widget.CardView>
<TextView
android:id="@+id/tv_register"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Do not have account? Register here!"
android:layout_alignParentBottom="true"
android:textColor="#1A237E"
android:layout_centerHorizontal="true"
android:layout_marginBottom="13dp" />
</RelativeLayout>

28
ANDROID MANIFEST:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.sucheta.sidemenu">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="SMART ACADEMICS"
android:roundIcon="@mipmap/ic_launcher"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity
android:name=".SplashActivity"
android:screenOrientation="portrait">
<intent-filter>
<action android:name="android.intent.action.MAIN" /
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity
android:name=".SelectActivity"
android:screenOrientation="portrait" />
<activity
android:name=".SideMenuMainActivity"
android:screenOrientation="portrait" />
<activity
android:name=".SideMenuTeacherActivity"
android:screenOrientation="portrait" />
<activity
android:name=".MyAccount"
android:screenOrientation="portrait" />
<activity
android:name=".MyLecturePlan"
android:screenOrientation="portrait" />
<activity
android:name=".LoginActivity"
android:screenOrientation="portrait" />

29
 <activity
android:name=".LoginstudActivity"
android:screenOrientation="portrait" />
<activity
android:name=".RegisterstudActivity"
android:screenOrientation="portrait" />
<activity
android:name=".MyTeacherAccount"
android:screenOrientation="portrait" />
<activity
android:name=".MyFileUpload"
android:screenOrientation="portrait" />
<activity
android:name=".TakeAttendance"
android:screenOrientation="portrait" />
<activity
android:name=".ShowAttendance"
android:screenOrientation="portrait" />
<activity android:name=".FileDownload"
android:screenOrientation="portrait"/>
<activity android:name=".ShowAttendanceTeacher"
android:screenOrientation="portrait"></activity>
</application>
</manifest>

LOGIN CODE OF TEACHER:

package com.example.sucheta.sidemenu;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.support.design.widget.TextInputLayout;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.view.menu.SubMenuBuilder;
import android.text.InputType;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;

30
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import com.android.volley.NetworkError;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.ServerError;
import com.android.volley.TimeoutError;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.Volley;
import org.json.JSONException;
import org.json.JSONObject;
public class LoginActivity extends AppCompatActivity
{

public static String PREFS_NAME="mypre";

public static String PREF_USERNAME="username";
public static String PREF_PASSWORD="password";
EditText et_username,et_pass;
Button btn_login;
TextView tv_register;
String username,password;
CheckBox teach_show_pswd;
SharedPreferences pref;
SharedPreferences.Editor editor;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Full screen mode
this.requestWindowFeature(Window.FEATURE_NO_TITLE);
this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
this.setContentView(R.layout.activity_login);
setContentView(R.layout.activity_login);
et_username=(EditText)findViewById(R.id.et_username);
et_pass=(EditText)findViewById(R.id.et_pass);
btn_login=(Button)findViewById(R.id.btn_login);
tv_register=(TextView)findViewById(R.id.tv_register);
teach_show_pswd=(CheckBox)findViewById(R.id.cb_showpswdteacher);
teach_show_pswd.setOnCheckedChangeListener(new
CompoundButton.OnCheckedChangeListener() {
@Override
31
 public void onCheckedChanged(CompoundButton compoundButton, boolean b) if(b){

et_pass.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
}
else{ et_pass.setInputType(InputType.TYPE_CLASS_TEXT |
InputType.TYPE_TEXT_VARIATION_PASSWORD);
}
}
});
if (isNetworkAvailable()) {
final RequestQueue requestQueue = Volley.newRequestQueue(LoginActivity.this);
btn_login.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
pref=getSharedPreferences("login.conf",Context.MODE_PRIVATE);
editor=pref.edit();
username = et_username.getText().toString();
password = et_pass.getText().toString();
if (validateUsername(username) && validatePassword(password)) {
final ProgressDialog progressDialog = new ProgressDialog(LoginActivity.this);
progressDialog.setTitle("Please Wait");
progressDialog.setMessage("Logging You In");
progressDialog.setCancelable(false);
progressDialog.show();
LoginRequest loginRequest = new LoginRequest(username,password, new
Response.Listener<String>() {
@Override
public void onResponse(String response) {
progressDialog.dismiss();
try { JSONObject jsonObject = new JSONObject(response);
if (jsonObject.getBoolean("success")) {
Intent loginSuccess = new Intent(LoginActivity.this,SideMenuTeacherActivity.class);
overridePendingTransition(R.anim.right_in,R.anim.left_out);
loginSuccess.putExtra("name", jsonObject.getString("name"));
loginSuccess.putExtra("email", jsonObject.getString("email"));
loginSuccess.putExtra("mobile", jsonObject.getString("mobile"));
startActivity(loginSuccess)
finish();
}
else {
if (jsonObject.getString("status").equals("INVALID"))
Toast.makeText(LoginActivity.this, "User Not Found",
Toast.LENGTH_SHORT).show();

32
 else { Toast.makeText(LoginActivity.this, "Passwords Don't Match",
Toast.LENGTH_SHORT).show(); } }} catch (JSONException e) { e.printStackTrace();
Toast.makeText(LoginActivity.this, "Bad Response From
Server",Toast.LENGTH_SHORT).show();
} }}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
progressDialog.dismiss(
if (error instanceof ServerError)
Toast.makeText(LoginActivity.this, "Server Error", Toast.LENGTH_SHORT).show();
else if (error instanceof TimeoutError
Toast.makeText(LoginActivity.this, "Connection Timed Out",
Toast.LENGTH_SHORT).show();
else if (error instanceof NetworkError)
Toast.makeText(LoginActivity.this, "Bad Network Connection",
Toast.LENGTH_SHORT).show();
}});
requestQueue.add(loginRequest);}
//Don't Have An Account TextView Clicked
tv_register.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(LoginActivity.this, RegisterActivity.class);
startActivity(intent);
overridePendingTransition(R.anim.right_in,R.anim.left_out);
}
});
} else {
Toast.makeText(LoginActivity.this, "No Internet Connection!!!",
Toast.LENGTH_SHORT).show();
}
}
private boolean isNetworkAvailable() {
ConnectivityManager connectivityManager = (ConnectivityManager)
getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
return activeNetworkInfo != null && activeNetworkInfo.isConnected();
}
private boolean validateUsername(String string) {
//Validating the entered USERNAME
if (string.equals("")) {
et_username.setError("Enter a Username");
return false;
} else if (string.length() > 50) {
33
 et_username.setError("Maximum 50 Characters");
return false;
} else if (string.length() < 6) {
et_username.setError("Minimum 6 Characters");
return false;
}
return true;
}
private boolean validatePassword(String string) {
if (string.equals("")) {
et_pass.setError("Enter Your Password");
return false;
} else if (string.length() > 32) {
et_pass.setError("Maximum 32 Characters");
return false;
} else if (string.length() < 8) {
et_pass.setError("Minimum 8 Characters");
return false;
}
return true;
}
}

JSON PARSER:
package com.example.sucheta.sidemenu;
import com.android.volley.AuthFailureError;
import com.android.volley.Response;
import com.android.volley.toolbox.StringRequest;
import java.util.HashMap;
import java.util.Map;
public class LoginRequest extends StringRequest {
privatestaticfinalStringLOGIN_URL="https://palitdipayan57.000webhostapp.com/teach_logi
n.php";
private Map<String, String> parameters;
public LoginRequest(String username,String password, Response.Listener<String> listener,
Response.ErrorListener errorListener) {
super(Method.POST, LOGIN_URL, listener, errorListener);
parameters = new HashMap<>();
parameters.put("username", username);
parameters.put("password", password); }
@Override
protected Map<String, String> getParams() throws AuthFailureError {
return parameters;

34
CHAPTER 5:
Testing
Implementation and Testing:
A software system test plan is a document that describes the objectives, scope, approach, and
focus of software testing effort. The process of preparing a test plan is a usual way to think
way to think the efforts needed to validate the acceptability of a software product. The
complete document will help people outside the test group understand the “WHY” and
“HOW” product validation. It should be through enough to be useful but not so through that
no one outside the test group will read it.

Introduction:
Testing is the process of running a system with the intention of finding errors. Testing aims at
detecting error-prone areas. The main purpose of the testing is to detect errors and error-
prone areas in the system. Testing must be through and well planned.

Objectives of Testing:
The objective our test plan is to find and report as many bug as possible to improve the
integrity of our program. Although exhaustive testing is not possible, we will exercise a broad
range of tests to achieve our goal.

TESTING STRATEGY:
Test Case:
A test case is a document that describes an input, action, or event and expected response, to
determine if a feature of an application is working correctly. A test case should contain
particular such as test case identifier, test condition, input data.
Requirement expected result. The process of developing test cases can help find problems in
the requirement or design of an application, since it requires completely thinking through the
operation of the application.

Testing Steps:
Unit Testing:
Unit testing focuses efforts on the smallest unit of software design. This is known as module
testing. The modules are tested separately. The test is carried out during programming stage
itself. In this step, each module is found to be working satisfactory as regards t the expected
output from the module.
Integration Testing:
Once unit testing is complete, integration testing begins. In integration testing,
The units validated during unit testing are combined to form a subsystem. The purpose of
integration testing is to ensure that all the modules continue to work in accordance with
customer requirements even after integration.
The objective of integration testing is to take all the tested individual units, integrate them test
them again, and develop the software, which is according to design specifications

35
Test Type: Unit Testing

Test Case Number: 1

Test Case Name: Admin Identification

Test Case Description: The admin should enter his/her accurate admin id and
password so that he/she can able to go for the further
options. The test case will check the application for the
same since a teacher/student can only login with the
correct id and password..
Verification: Verification of the id and password with the reord in the
database.
Input Expected Output

1.Correct id and password 1.Successful message

2.Incorrect id and password 2.Failure Message

Test Type: Unit Testing

Test Case Number: 2

Test Case Name: Registration of Student and Teacher,

Test Case Description: Admin will enter the details in the registration form and
credentials will be checked by the validated used in the
form. After all the credentials are validated then only the
form will be submitted and data will be stored in the
database
Verification: Required fields in the form are not empty, validation of
poper credentials
Input Expected Output

1 .id, name, password, mobile, email 1.Successful registration

2.Empty field, Invalid entry 2.Failure Message

36
White Box testing:
In white Box testing, the UI is bypassed. Inputs and outputs are tested directly at the code
level and the results are compared against specifications. This form of testing ignores the
function of the program under test and will focus only on its code and structure of that code.
Because the functionality of the program is relatively simple, the method will be feasible to
apply.

Black Box Testing:

Black box testing typically involves running through every possible input to verify that it
results in the right outputs using the software as an end-user would. We have decided to
perform Equivalence Partitioning and boundary Value Analysis testing on our application.

System Testing:
The goals of system testing are to detect faults that can only be exposed by testing the entire
integrated system or some major part of it. This testing mainly focuses on security,
performance, validation, load/stress and configuration sensitivity.

Goal of Testing:
“Program testing can be used to slow the presence of bug, but never to slow their absence”. If
the results delivered by the system are different from the expected ones then the system is
incorrect and these bugs should be fixed.

Database Security:
System security measure is meant to be provided to make your system reliable and secured
from unauthorized user may create threats to the system. So you should follow some security
measures. We have used security levels in database level at system level.

System Security:
If we talk about the system security in our proposed system we have implemented with the
help of maintain the session throughout the system’s use. Once user has logged out then
teacher/student will not be able to perform any ask before login back again.
A high level authentic login is given to the system so this is a very tedious task to enter
without authorization and authentication.
Limitation:
 Since it is an online application, so user must have internet connection to use
it.
 Users must have their respective email id to login into the applications.

37
CHAPTER 6

Summary, Conclusion and Future Scope

Summary:

Based on results of the evaluation of the android application, the respondents strongly
expressed their appreciation of acceptance and satisfaction of the developed mobile teaching
and learning android application. The following are the findings of the study:
1. In terms of Design and User Interface, the mobile application was rated as highly
acceptable. The application shows that it has good visual design i.e. suited for student
and teacher both.
2. In terms of functionality, the mobile application was rated highly acceptable. The
modules and specified operations run properly and smoothly.
3. In terms of Performance and stability, the application performed the operation without
error and bugs and with specified time.

Conclusion:

The mobile application is developed as user friendly which the user understand the content of
the application easily. The application is for teacher and student both. The application is
made in graphic design. It gives attractive design or graphic which convince to all to use the
application for their experience.

Future Scope and Further Enhancements

In future we would like to keep working on this project and make new additions to provide
users with more advanced features and more detailed information. We have set our sights on
the following additions in future:
1. Forget Password for admin and application section.
2. Student -Teacher communication for better understanding.
3. Chatbot of college for new comers.
4. Improve teaching learning process.
5. Performance Measurement of the student.

38
CHAPTER 7

References

References Books

1. Head First Android Development by Jonathan Simon.

2. The Complete References of Java by Herbert Schildt.

References Website
https://developer.android.com

https://stackoverflow.com

https://github.com/

https://www.udemy.com/courses/android

39