University android app

KUVEMPU UNIVERSITY APP
Dept. of Computer Science and MCA, Jnana Sahyadri Page 1
1.1 Introduction:
Kuvempu University is a public state university located in Shivamogga. It was
established in 1987 by the act of the Karnataka state legislature through an amendment
No.28/1976 dated 29 January 1989 under the Karnataka State University Act 1976.The
university offers undergraduate and graduate degree programs in wide range of disciplines. It
occupies 230 acres (0.93 km2) of land.
The university has its headquarters at Jnana Sahyadri Campus, Shimoga. Its campus is
called Jnana Sahyadri, which means The Western Ghat section of knowledge. It has as
university jurisdiction over malnad districts of Shimoga and Chickamagalur, through which
the Sahyadri mountain ranges pass. It also covers districts of Davangere and Chitradurga. The
campus sprawls across an area of 230 acres. Nature was never so beautiful before like it is
inside Jnana Sahyadri.
The university has 59 post-graduate departments of studies in the faculties
of Arts, Science, Commerce, Education and Law, offering 45 post-graduate (PG) programs,
four PG diplomas(regular) and one undergraduate programme. There are many colleges
affiliated to this university offering undergraduate courses in the above-mentioned faculties.
The main goal of our project is to develop “KUVEMPU UNIVERSITY” app is, this
app is very useful for every users to get information about kuvempu university, results,
admissions, examinations, scholarship details, library facilities, map.
Since kuvempu university application is been developed in the android platform it
requires the “ANDROID STUDIO” development environment, java development kit (JDKs).
Kuvempu university app is preferred to be an application to be intended in the android
OS. It is very must to be familiar with the key components of ANDROID.

The first section of this report deals with the basic requirements for using the
Kuvempu University. The next sections contain detailed explanation of the process of
generation and verification of the Kuvempu University. In addition to this the applications of
the Kuvempu University are also discussed. The report also focuses on some legal aspects of
Kuvempu University, with reference to the Information Technology Act. The use of
Kuvempu University has been illustrated with an example in a practical scenario.
This report is an attempt to make the readers familiar with the concepts related to the
Kuvempu University and give them an idea of usefulness of a Kuvempu University in the
world of electronic information exchange.
1.2 Problem statement:
kuvempu university already has web site, but many users can’t understand how to
access the required information. The existing web site is not so user friendly.
Now a day every facility is available through their respective app. So for this reason
we created this application to provide a basic information because everyone users also
depend on ANDROID applications today.

1.3 Objective of this project:
The main purpose behind the proposed system is to provide a comprehensive android
application of kuvempu university.
Once the user installs this android application. Then the user can easily, and quickly
access to the facilities provided by the application. We integrated some features of current
kuvempu university website and also other useful web links.
The main Objectives are,
 Open software(source) platform for mobile application development
 A complete stack – OS, Middleware, Applications
 An Open Handset Alliance (OHA) project
 Powered by Linux operating system
 Fast & easy application development
1.4 Advantages of our project
The Main advantages are listed below:
 To easily download the required documents regarding admission.
 The student can easily get to know the available PG courses.
 To save browsing time and improve the browsing experience.
 To provide the academic and campus view of the university via the photo gallery.
 To view the kuvempu university over the google map.
 To provide the scholarship information and education loans for the students.
 To provide the results and examination information for the students.
 To provide the Web-OPAC service within the university campus.
 It can be sharable.

2.1 Introduction
System analysis in systems engineering and software engineering, encompasses those
tasks that go into determining the needs or conditions to meet for a new or altered product,
taking account of the possibly conflicting requirements of the various stakeholders, such as a
beneficiaries or users. Requirements analysis is critical to the success of a development
project. Requirements must be documented, actionable, measurable, testable, related to
identified business needs or opportunities, and defined to a level of detail sufficient for
system design. Requirements can be functional and nonfunctional.
2.2 Drawbacks of existing system
Now a day we have website for our kuvempu university and it’s not user friendly. We
need some browser to access it, so it is time consuming. And also we have some difficulties
which are arises while searching for specified information. In order to overcome these
difficulties, we go for simple and user friendly apps.
kuvempu university already has web site, but many users can’t understand how to
access the required information. The existing web site is not so user friendly.
Now a day every facility is available through their respective app. So for this reason
we created this application to provide a basic information because everyone users also
depend on ANDROID applications today.
2.3 Proposed system:
Considering the drawbacks in the existing system in the mind the new system should
be developed. In proposed system we propose software which can keep all the data in
organized manner and can make the entire process automated without the worry of
inconsistency in the data.
Now a day every activity is done through some respective apps, the main goal of us is
to develop an app that include some feature available in website and also we include a unique
feature those will helps to the various users.

The main advantages of proposed system:
• Time efficient.
• Anybody can easily access.
• Contains many additional feature than the existing system.
• Easy to access required information.
2.4 System Requirement Specification
2.4.1 Introduction
The main task is to identify the requirements. So the requirement phase translates the
ideas in the client's mind into formal document. The software requirements document
(sometimes called software requirement specification or SRS) is the official statement of
what is required of the system developers. It should include both the user requirements for a
system and a detailed specification of the system requirements. The basic purpose of software
requirement specification is to bridge the communication gap between the client and
developer. It also helps the clients to understand their own needs.
The main advantage in developing an SRS is:
 An SRS establishes the basis for agreement between the client and developer on what
the software product will do.
 An SRS provides a reference for validation of final document.
 A high quality SRS is prerequisite to high quality software.
 A high quality SRS reduces the development cost.
 The requirement phase consists of three basic activities:
• Problem or Requirement Analysis.
• Requirement Specification.
• Requirement Validation.

A good SRS is:
• Correct
• Complete
• Unambiguous.
• Verifiable
• Consistent
• Ranked for important and stability.
• Modifiable
• Traceable
The basic issues an SRS must address are:
l. Functionality.
2. Performance.
3. Design constraints imposed on an implementation external interface.
2.4.2 Purpose
The purpose of software requirement specification is to gather all the requirements of
the users. The users will use the completed system. The problem is that the clients usually
cannot able to understand software or the software development requirements.
Thus a Communication gap will occur between the parties involved in the
development of the Project. The purpose of developing an SRS is helping the clients to
understand their own needs.
2.4.3 Goals
The goals aimed by software requirement specification phase are as follows:
• Low Installation Cost
• Quick set up time
• Low Maintenance
Hence the Software requirement specification is made for the project "Kuvempu
University" and is supplied to all the users including the students, faculty and different users
of the android phone.

2.5 MINIMUM SYSTEM REQUIREMENTS
Hardware Requirements:
For developing the application:
 Processor : 1 GHz
 For accelerated emulator : 64-bit operating system and Intel processor
with support for Intel VT-x
 Monitor : 1280 x 720 resolution
 RAM : 2 GB
 Hard Disk : 2 GB (500 MB for IDE + 1.5 GB for
Android SDK and emulator system)
For running the application:
 Device : Android version 2.3 and above
 Minimum space to execute : 10 MB
Software Requirements:
For developing the application:
 Operating System : Microsoft Windows 7 or later version
 Database : SQLite
 Tools : Android Studio, JDK 5, JRE 6
 Technologies used : Java, XML
 Debugger : Android Dalvik Debug service
For running the application:
 Operating System : Android
 Version : Gingerbread (2.3) or Later
 Security:
Setting  Application  Unknown Sources - Checked

3.1 INTRODUCTION:
Based on the user requirements and the detailed analysis of a new system, the new
system must be designed. This is the phase of system designing. It is a most crucial phase in
the development of a system.
Normally, the design proceeds in two stages:
l. Preliminary or general design
2. Structure or detailed design
Preliminary or general design:
In the preliminary or general design, the features of the new system are specified. The
costs of implementing these features and the benefits to be derived are estimated. If the
project is still considered to be feasible, we move to the detailed design stage.
Structure or detailed design:
In the detailed design stage, computer oriented work begins in earnest. At this stage,
the design of the system becomes more structure design is a blue print of a computer system
solution to a given problem having the same components and interrelationship among the
same components as the original problem. Input, output and processing specification are
drawn up in detail. In the design stage, the programming language and the platform in which
the new system will run are also decided.
3.2 Architecture of the Android system:
The below figure shows the diagram of Android Architecture. The Android OS can be
referred to as a software stack of different layers, where each layer is a group of several
program components. Each layer in the architecture provides different services to the layer
just above it.

3.2.1 LINUX KERNEL:
The basic layer is the Linux kernel. The whole Android OS is built on top of the
Linux 2.6 Kernel with some further architectural changes made by Google. It is this Linux
that interacts with the hardware and contains all the essential hardware drivers. Drivers are
programs that control and communicate with the hardware. For example, consider the
Bluetooth function. All devices has a Bluetooth hardware in it. Therefore the kernel must
include a Bluetooth driver to communicate with the Bluetooth hardware.
The Linux kernel also acts as an abstraction layer between the hardware and other
software layers. Android uses the Linux for all its core functionality such as Memory
management, process management, networking, security settings etc. As the Android is built
on a most popular and proven foundation, it made the porting of Android to variety of
hardware, a relatively painless task.

3.2.2 LIBRARIES:
On top of Linux kernel there is a set of libraries including open-source Web browser
engine WebKit, well known library libc, SQLite database which is a useful repository for
storage and sharing of application data, libraries to play and record audio and video, SSL
libraries responsible for Internet security etc.
3.2.3 ANDROID LIBRARIES:
This category encompasses those Java-based libraries that are specific to Android
development. Examples of libraries in this category include the application framework
libraries in addition to those that facilitate user interface building, graphics drawing and
database access. A summary of some key core Android libraries available to the Android
developer is as follows.
android.app − Provides access to the application model and is the cornerstone of all Android
applications.
android.content − Facilitates content access, publishing and messaging between applications
and application components.
android.database − Used to access data published by content providers and includes SQLite
database management classes.
android.opengl − A Java interface to the OpenGL ES 3D graphics rendering API.
android.os − Provides applications with access to standard operating system services
including messages, system services and inter-process communication.
android.text − Used to render and manipulate text on a device display.
android.view − The fundamental building blocks of application user interfaces.
android.widget − A rich collection of prebuilt user interface components such as buttons,
labels, list views, layout managers, radio buttons etc.
android.webkit − A set of classes intended to allow web-browsing capabilities to be built
into applications.
Having covered the Java-based core libraries in the Android runtime, it is now time to
turn our attention to the C/C++ based libraries contained in this layer of the Android software
stack.

3.2.4 ANDROID RUNTIME:
Android Runtime consists of Dalvik Virtual machine and Core Java libraries.
• Dalvik Virtual Machine:
It is a type of J VM used in android devices to run apps and is optimized for low
Processing power and low memory environments. Unlike the JVM, the Dalvik Virtual
Machine doesn't run .class files, instead it runs .dex files. .dex files are built from .class file at
the time of compilation and provides higher efficiency in low resource environments. The
Dalvik VM allows multiple instance of Virtual machine to be created simultaneously
providing security, isolation, memory management and threading support. It is developed by
Dan Bornstein of Google.
• Core Java Libraries:
These are different from Java SE and Java ME libraries. However, these libraries
provide most of the functionalities defined in the Java SE libraries.
3.2.5 APPLICATION FRAMEWORK
These are the blocks that our applications directly interacts with. These programs
manage the basic functions of phone like resource management, voice call management etc.
As a developer, you just consider these are some basic tools with which we are building our
applications.
Important blocks of Application framework are:
• Activity Manager: Manages the activity life cycle of applications
• Content Providers: Manage the data sharing between applications
• Telephony Manager: Manages all voice calls. We use telephony manager if we
want to access voice calls in our application.
• Location Manager: Location management, using GPS or cell tower
• Resource Manager: Manage the various types of resources we use in our Application

3.2.6 APPLICATIONS
Applications are the top layer in the Android architecture and this is where our
applications reside. Several standard applications come pre-installed with every device,
such as:
• SMS client app
• Dialer
• Web browser
• Contact manager
As a we are able to write an app which replace any existing system app. That is, you
are not limited in accessing any particular feature. You are practically limitless and can
whatever you want to do with the android (as long as the users of your app permits it). Thus
Android is opening endless opportunities to the developer.
3.3 MODULES
A module is a collection of source files and build settings that allow you to divide
your project into discrete units of functionality. Your project can have one or many modules
and one module may use another module as a dependency. Each module can be
independently built, tested, and debugged. Additional modules are often useful when creating
code libraries within your own project or when you want to create different sets of code and
resources for different device types, such as phones and wearables, but keep all the files
scoped within the same project and share some code.
We can add module to our project by clicking File > New > New Module.
Android studio offers a few distinct types of module:
Android app module
Provides a container for your app's source code, resource files, and app level settings
such as the module-level build file and Android Manifest file. When you create a new
project, the default module name is "app".

In the Create New Module window, Android Studio offers the following app modules:
 Phone & Table Module
 Android Wear Module
 Android TV Module
 Glass Module
They each provide essential files and some code templates that are appropriate for the
corresponding app or device type.
Library module
Provides a container for your reusable code, which you can use as a dependency in
other app modules or import into other projects. Structurally, a library module is the same as
an app module, but when built, it creates a code archive file instead of an APK, so it can't be
installed on a device.
In the Create New Module window, Android Studio offers the following library modules:
 Android Library: This type of library can contain all file types supported in an
Android project, including source code, resources, and manifest files. The build result
is an Android Archive (AAR) file that you can add as a dependency for your Android
app modules.
 Java Library: This type of library can contain only Java source files. The build result
is an Java Archive (JAR) file that you can add as a dependency for your Andriod app
modules or other Java projects.
Google Cloud module
Provides a container for your Google Cloud backend code. This module adds the
required code and dependencies for a functioning, runnable backend that you can extend with
the features you want, such as data storage. Android Studio lets you easily add a cloud
backend to your app.
3.3.1 PROJECT FILES
By default, Android Studio displays your project files in the Android view. This view
does not reflect the actual file hierarchy on disk, but is organized by modules and file types to
simplify navigation between key source files of your project, hiding certain files or
directories that are not commonly used.

Within each Android app module, files are shown in the following groups:
manifests
Contains the AndroidManifest.xml file.
java
Contains the Java source code files, separated by package names, including JUnit test code.
res
Contains all non-code resources, such as XML layouts, UI strings, and bitmap images,
divided into corresponding sub-directories.
3.3.2 THE BUILD PROCESS
The build process involves many tools and processes that convert your project into an
Android Application Package(APK). The build process is very flexible, so it's useful to
understand some of what is happening under the hood.

The build process for a typical Android app module, as shown in figure 1, follows these
general steps:
1. The compilers convert your source code into DEX (Dalvik Executable) files, which
include the bytecode that runs onAndroid devices, and everything else into compiled
resources.
2. The APK Packager combines the DEX files and compiled resources into a single APK.
Before your app can be installed and deployed onto an Android device, however, the APK
must be signed.
3. The APK Packager signs your APK using either the debug or release keystore:
a. If you are building a debug version of your app, that is, an app you intend only for
testing and profiling, the packager signs your app with the debug keystore. Android Studio
automatically configures new projects with a debug keystore.
b. If you are building a release version of your app that you intend to release
externally, the packager signs your app with the release keystore. To create a release
keystore, read about Signing your app in Android Studio.
4. Before generating your final APK, the packager uses the zipalign tool to optimize your app
use less memory when running on a device.
At the end of the build process, you have either a debug APK or release APK of your
app that you can use to deploy, test, or release to external users.
3.4 ACTIVITY LIFECYCLE
If you have worked with C, C++ or Java programming language then you must have
seen that your program starts from main function. Very similar way, Android system initiates
its program with in an Activity starting with a call on onCreate callback method. There is a
sequence of callback methods that start up an activity and a sequence of callback methods
that tear down an activity as shown in the below Activity life cycle diagram
The Activity class defines the following call backs i.e. events. You don't need to
implement all the callbacks methods. However, it's important that you understand each one
and implement those that ensure your app behaves the way users expect.

Example for Activity
public class MainMenu extends Activity
{
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main_menu);
}
}
Callback Description
onCreate() This is the first callback and called when the activity is first created.
onStart() This callback is called when the activity becomes visible to the user.
onResume() This is called when the user starts interacting with the application.
onPause() The paused activity does not receive user input and cannot execute
any code and called when the current activity is being paused and
the previous activity is being resumed.
onStop() This callback is called when the activity is no longer visible.
onDestroy() This callback is called before the activity is destroyed by the
system.
onRestart() This callback is called when the activity restarts after stopping it.

3.5 DATA FLOW DIAGRAM

4.1 INTRODUCTION:
Implementation is the stage of the project where the theoretical design is turned into a
working system. At this stage the main load, the greatest upheaval and the major impact on
the existing system shifts to the user department.
Implementation includes all those activities that take place to convert from the old
system to the new one. The new system may be totally new, replacing an existing manual
system. Proper implementation is essential to provide a reliable system to meet the
organization requirements. Successful implementation may not guarantee improvement in the
organization using the new system, but improper installation will prevent it.
The process of putting the developed system in actual use us called system
implementation. This includes all those activities that take place to convert from the old
system to the new system. The system can be implemented only after through testing is done
and if it is found to be working according to the specifications. The system personal check
the feasibility of the system.
The most crucial stage is achieving a new successful system and gibing confidence on
the new system for the used that it will work efficiently and effectively. It involves careful
planning, investigation of the current system and its constraints on implementation design of
methods to achieve the changeover. The more complex the system being implemented, the
more involve will be the system analysis and the design effort required just for
implementation.
4.2 ABOUT TOOLS:
4.2.1 Software development kit
The Android SDK includes a comprehensive set of development tools. These include
a debugger, libraries, a handset emulator, documentation, sample code, and tutorials.
Currently supported development platforms include x86-architecture computers running
Linux (any modern desktop Linux distribution), Mac OS X 10.4.8 or later, Windows XP or
Vista. Requirements also include Java Development Kit, Apache Ant, and Python 2.2 or later.
The officially supported integrated development environment (IDE) is Android
Studio, though developers may use any text editor to edit Java and XML files then use

command line tools to create, build and debug Android applications as well as control
attached Android devices (e.g.,installing software packages). A preview release of the
Android software development kit (SDK) was released on 12 November 2007.
 android.jar:
Java archive file containing all of the Android SDK classes necessary to build our
application.
 document.html and docs directory:
The SDK documentation is provided locally and on the web. It's largely in the form of
Java Docs, making it easy to navigate the packages in the SDK. The documentation
also includes a high level development Guide and links to the broader Android
community.
 Tools directory:
It contains all of the command line tools to build Android applications. The most
commonly employed and useful tool is the adb utility ( Android Debug Bridge).
 Samples directory:
The samples subdirectory contains full source code for a variety of
applications,including API demo, which excercise many API's. The sample application
is a great place to explore when starting Android application development.
 USB driver:
Directory containing the necessary drivers to connect the development environment
to an Android enabled device. Such as the G 1 or the Android Dev 1 unlocked
development phone. These files are only required for developers using the windows
platform.
 ADB ( Android Debug Bridge):
The ADB utility let us connect to the phone itself and issue rudimentary shell
commands, such as copying files to and from the devices.

4.2.2 OPEN HANDSET ALLIANCE (OHA):
This barrier to application development began to crumble in November of 2007 when
Google, under the Open Handset Alliance, released Android. The Open Handset Alliance is a
group of hardware and software developers, including Google, NTT DoCoMo, Sprint Nextel,
and HTC, whose goal is to create a more open cell phone environment. The first product to
be released under the alliance is the mobile device operating system, Android.
With the release of Android, Google made available a host of development tools and
tutorials to aid would-be developers onto the new system. Help files, the platform software
development kit (SDK).
In keeping with the Open Handset Alliance's theme of truly opening the mobile
Development market, Android studio is one of the most fully featured, free, Java IDE's
available. Android studio is also very easy to use, with a minimal learning curve. This makes
Android studio a very attractive IDE for solid, open Java development.
Android studio is the platform upon which the plug-in runs. Android application
development under the Android studio environment requires knowledge of the Android
studio environment and the Android platform. An understanding of the terms below is helpful
in Android application development with the Android studio plug-in.
 The Package Explorer:
The Package Explorer (found in the Java perspective in Android studio) displays all
the components of the sample Android application.
• AndroidManifest.xml snippet: This file is the application deployment descriptor for
Android applications.
• IntentReceiver: This demonstrates the implementation of an IntentReceiver, which is
the class that processes intents as advertised by the IntentFilter tag in the
AndroidManifest.xml file.
• SaySomething.java: This implements an Android activity, the primary entry point to
the sample application of this tutorial.
• Main.xml: This contains the visual elements, or resources, for use by Android activities.

• R.java: This file is automatically generated by Android Developer Tools and "connects" the
visual resources to the Java source code.
• AndroidManifest.xml complete: This lists a full AndroidManfest.xml file, along with a
description of each of the important elements.
• res folder: Resources in Android are organized into a subdirectory of the project named res,
as described previously. Resources fall into three primary categories:
• Drawables: This folder contains graphics files, such as icons and bitmaps
• Layouts: This folder contains Xlv1L files that represent the layouts and views
of the application.
• Values: This folder contains a file named strings.xml. This is the primary
means for string localization for the application.
4.2.3 EMULATOR:
A software tool representative of another system, This is often an environment that
runs on a personal computer that emulates another environment, such as a mobile-computing
device. Arguably one of the most important tools included in the Android SDK is emulator.
emulator.exe launches the Android Emulator. The Android Emulator is used to run your
applications in a pseudo-Android environment. Given that, as of the writing of this book,
there were no hardware devices yet released for the Android platform, emulator.exe is going
to be your only means to test applications on a "native" platform.
You can run emulator.exe from the command line or execute it from within Android
Studio. However, in the interest of giving you all the information you need to program with
the Android Studio.
 IDE (Integrated Development Environment):
A software application that consists of a source code editor. A compiler, build
automation tools and a debugger. It makes programming and running applications
easier.
 ADT (Android Development Tools) :
A plug-in for Android studio that extends the Android studio IDE by providing
more tools to develop Android Applications.

 AVD (Android Virtual Device):
An Android emulator that allows you to simulate how the application will run
on unactual Android device.
4.2.4 JDK (Java SE Development Kit):
A popular Java SDK that is used to program Android applications.
 Activity:
An Activity represents the main screen for Android application. An application can
any number of Activities. Intents are message passing mechanisms used in Android. Android
Activity class contains different methods that support Activity communication. The method
startActivity(Intent) is used to invoke one Activity from other Activity. This method accepts
an Intent object which specifies the Activity to be started. If the FirstActivity is expecting
some result from Second Activity, a variation of this method is to be used. For example, if we
want to start an activity that allows the user to choose a person from the contacts list and
when it finishes execution, it will return the selected person.
 Views:
The Android activity employs views to display UI elements. Views are defined in an
XML file. Views follow one of the following layout designs:
• LinearVerticaI: Each subsequent element follows its predecessor by flowing beneath it in a
single column.
• LinearHorizontal: Each subsequent element follows its predecessor by flowing to the right
in a single row.
• Relative: Each subsequent element is described in terms of offsets from the prior element.
• Table: A series of rows and columns similar to HTML tables. Each cell can hold one view
element. Once a particular layout (or combination of layouts) has been selected, individual
views are used to present the UI.
View elements consist of familiar UI elements, including:
• Button
• ImageButton
• EditText
• TextView (similar to a label)
• CheckBox

• Radio Button
• Gallery and ImageSwitcher for displaying multiple images
• List
• Grid
• DatePicker
• TimePicker
• Spinner (similar to a combo box)
• AutoComplete (EditText with auto text-complete feature)
4.2.5 Android Application Life Cycle
The Android application life cycle IS unique in that the system controls much of the
lifecycle of the application. All Android applications, or Activities, are run within their own
process. All of the running processes are watched by Android and, depending on how the
activity is running (this is, a foreground activity, background activity, and so forth), Android
may choose to end the activity to reclaim needed resources.
Some of the specific methods called during the life cycle of an android activity are
• onCreate
• onStart
• Process-specific events (for example: launching activities or accessing a database)
• onStop
• onDestroy
4.3 OVERVIEW OF JAVA
Java started out as a bit of an accident. A team under Bill Joy was working at Sun on a
new programming language for embedded applications. Java was originally expected to work
in toasters and fridges, not on modern computers. The initial prognosis for Java was not good
and it was only the rise of the Internet which saved Java from oblivion.
World Wide Web is an open ended information retrieval system designed to be used
in the distributed environment. This system contains web pages that provide both information
and controls. We can navigate to a new web page in any direction. This is made possible
worth HTML java was meant to be used in distributed environment such as internet. So java

could be easily incorporated into the web system and is capable of supporting animation
graphics, games and other special effect. The web has become more dynamic and interactive
with support of java. We can run a java program on remote machine over internet with the
support of web.
4.3.1 JAVA PROGRAMMING
Introduction:
Java was introduced by James Gosling, Patrick Naughton, Chris Wrath, Ed Frank, and
Mike Sheridan at Sun Micro system. It is an platform independent programming language
that extends its features wide over the network.
Java language
Java is two things: a programming language and a platform.
Java Programming Language
Java is a high-level programming language that is all of the following:
• Simple
• Object-oriented
• Distributed
• Interpreted
• Robust
• Secure
• Architecture-neutral
• portable
• High-performance
• Multithreaded
• Dynamic
Java is also unusual in that each Java program is both compiled and interpreted. With
a compiler, you translate a java program into an intermediate language called Java
bytecodes—the platform-independent codes interpreted by the Java interpreter. With an
interpreter, each Java byte code instruction is parsed and run on the computer. Compilation
happens just once; interpretation occurs each time the program is executed. Java byte codes
can be considered as the machine code instructions for the Java virtual machine (Java VM).

Every Java interpreter, whether it is a java development tool or a Web browser that can run
Java applets, is an implementation of the Java VM. The Java VM can also be implemented in
hardware.
Java byte codes help make "make once, run anywhere" possible. The Java program
can be compiled into byte codes on any platform that has a Java compiler The byte codes can
then be run on any implementation of the Java VM. For example, the same Java program can
on Windows NT, Solaris, and Macintosh.
4.3.2 The Java platform
A platform is the hardware or software environment in which a program runs. The
Java software-only platform that runs platform differs from most other platforms in that it is a
on top of other, hardware based platforms.
Most other platforms are described as combination of hardware and operating system.
The Java platform has two components:
• The Java Virtual Machine (Java VM)
• The Java Application Programming Interface (Java API)
The Java API is a large collection of ready-made software components that provide
many useful capabilities, such as graphical user interface (GUI) widgets. The Java API is
grouped Into libraries (packages) and related components.
Java can do many things like , Probably the most well-known Java programs are java
Applets. An applet is a Java program that adheres to certain conventions that allow it to run
within a Java-enabled browser.
However, Java is not just for writing cute, entertaining applets for the World Wide
Web ("Web"). Java is a general purpose, high-level programming language and a powerful
software platform. The most common types of programs are probably applets and
applications, where a Java application is a standalone program that runs directly on the Java
platform.
The core API gives the following features:
• The Essentials: Objects, Strings, threads, numbers, input and output, data structures,
system properties, date and time, and so on.

• Applets: The set of conventions used by Java applets.
• Networking: URLs, TCP and sockets, and IP addresses.
• Internationalization: Help for writing programs that can be localised for users
worldwide. Programs can automatically adapt to specific locales and be displayed in
the appropriate language.
• Security: Both low-level and high-level, including electronic signatures, public/private
key management, access control, and certificates.
• Software components: Known as JavaBeans, can plug into existing component
architectures such as Microsoft's OLE.COM/Active-x architecture, OpenDoc, and
Netscape's Live Connect.
• Java Database Connectivity (JDBC): Provides uniform access to a wide range of
relational database. Java not only has a Core API, but also standard extensions.
Define APIs for 3D, servers, collaboration, telephony, speech, animation, and more.
• Get started quickly: although Java is a powerful object-oriented language, it is easy
to learn, especially for programmers already familiar with C or C++.
• Write less code: Comparisons of program metrics (class counts, method counts, and
so on ) suggest that a program written in Java can be four times smaller than the same
program in C++.
• Write once, run anywhere: Because 100% pure Java programs are compiled into
machine-independent byte codes, they run consistently on any java platform.
4.4 XML
XML is a simple text based language which was designed to store and transport data
in plain text format. It stands for Extensible Markup Language. Following are some of the
salient features of XML.
• XML is a markup language.
• XML is a tag based language like HTML.
• XML tags are not predefined like HTML.
• You can define your own tags which is why it is called extensible language.
• XML tags are designed to be self descriptive.
• XML is W3C Recommendation for data storage and transport.

4.4.1 XML ON ANDROID
The Android platform is an open source mobile development platform. It gives you
access to all aspects of the mobile device that it runs on, from low level graphics, to hardware
like the camera on a phone. With so many things possible using Android, you might wonder
why you need to bother with XML. It is not that working with XML is so interesting; it is
working with the things that it enables. XML is commonly used as a data format on the
Internet. If you want to access data from the Internet, chances are that the data will be in the
form of XML. If you want to send data to a Web service, you might also need to send XML.
In short, if your Android application will leverage the Internet, then you will probably need to
work with XML. Luckily, you have a lot of options available for working with XML on
Android.
4.4.2 XMLPARSING
Parsing XML refers to going through XML document to access data or to modify
data in one or other way.
XML Parser provides way how to access or modify data present in an XML
document. Java provides multiple options to parse XML document. Following are various
types of parsers which are commonly used to parse XML documents.
Example for XML document can be used in Android:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical"
android:gravity="center_vertical" >
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
android:gravity="center_horizontal" />
<Button
android:id="@+id/nextButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/next" />
</LinearLayout>

5.1 INTRODUCTION
The important phase encountered in any developed product or framework is the
testing phase. It is because, the developed product should be free from errors and it should be
validated for accuracy. The product should work under normal conditions as long as the user
gives proper input and therefore it should be checked for its robustness and should withstand
and inform the users about the erroneous input.
The testing phase involves testing the system using various test data. Preparation of
the test data plays a vital role in the system testing. After preparing the test data, the system is
tested using those test data. Errors are found and corrected by using the following testing
steps and corrections are recorded for future reference. Thus a series of testing is performed
on the system before it is ready for implementation. Testing is applied at different levels in
the software development lifecycle. Each levels of testing is done is different in nature and
has different objectives at each level. The focus of all levels of testing is to find errors, but
different types of errors are looked for at each level. The quality of the system is confirmed
by the thoroughness of its testing. Duration and cost of testing and debugging is a significant
fraction of the system development cycle and hence influences overall productivity during the
development. In this phase, the errors in the programs or modules are localized and
modifications are done to eliminate them. The testing makes a logical assumption that all
parts of the system work efficiently and the goal is achieved.
• Testing is a process of executing a program with the intent of finding the error.
• A good test case is one that has high probability of finding an as-yet undiscovered error.
• A successful test one that uncovers an as-yet-undiscovered error.
5.2 FUNCTIONAL TESTING:
Black box testing: This approach tests all possible combinations of end-user actions.
Black box testing assumes no knowledge of code and is intended to simulate the end-user
experience. You can use sample applications to integrate and test the application block for
black box testing. You can begin planning for black box testing immediately after the
requirements and the functional specifications are available.

White box testing: This is also known as glass box, clear box, and open box testing. In
white box testing, you create test cases by looking at the code to detect any potential failure
scenarios. You determine the suitable input data for testing various APIs and the special code
paths that need to be tested by analyzing the source code for the application block. Therefore,
the test plans need to be updated before starting white box testing and only after a stable build
of the code is available.
5.3 SYSTEM TESTING:
System testing is actually a series of different tests whose primary purpose is to fully
exercise the computer-based system. Although each test has a different purpose, all work
should verify that all system elements have been properly integrated and perform allocated
functions.
RECOVERY TESTING is a system test that forces the software to fail in a variety of
ways and verifies that recovery is properly performed.
SECURITY TESTING attempts to verify that protection mechanisms built in to a system
will, in fact, protect it from improper penetrations.
STRESS TESTING executes a system in a manner that demands resources in abnormal
quantity, frequency, or volume.
PERFORMANCE TESTING is designed to test the run-time performance of software
within the context of the integrated system. Performance testing occurs throughout all
steps in the testing process.
5.3.1 Unit testing
In this testing we test each module individually. Unit testing focuses on the
verification of the smallest units of the software design the module. This is known as unit
testing. The modules of the system are tested separately. This test is carried out during
programming stage itself. Each module should work satisfactorily as regards to the expected
from the module. There are validation checks for the fields also.

5.3.2 Integration Testing
The program as a whole is integrated into a single component and checked with the
test data. This is to check that the whole program works together correctly. The various
modules are integrated first. Then the system is tested as a whole. The behavior of each
module with another is identified in this testing. Any misbehavior will lead to dangerous
problems or errors in the system. All these problems can be filtered off using this testing.
Here all the sub modules of one module in Mobile Banking are combined into a
single component and tested for integrity.
5.3.3 High Level Testing
High level testing involves the whole complete products. An independent test group
most appropriately performs it outside of the development organization usually.
5.3.4 Usability Testing
Usability testing involves having the user work with the product and observing their
response to it. Testing for whether we are getting graphical representation of image or not. ln
this project, different types of users worked with the product and the user responses are
observed. All the responses have been observed for all the modules in this project.

Here the first image shows the HOME SCREEN of Kuvempu
University App.
The second one shows the ADMISSIONS layout.

Here the first image shows the DISCIPLINES that are available
in Kuvempu University.
The second one shows the EXAMINATIONS layout.

Here the first image shows the SCHOLARSHIPS layout.
The second one shows the PHOTO GALLERY layout.

Here the first image shows the LIBRARY layout.
The second one shows the MAP & DIRECTIONS layout.

Here the first image shows the ABOUT US layout.
The second one shows the ABOUT KU layout showing some
information about Kuvempu University.

Here the first image shows the FACILITIES available in
Kuvempu University.
The second one shows the CONTACT US layout providing the
contact address.

CONCLUSION AND FUTURE ENHANCEMENT
Finally, we concluded that the Androids platform which has developed by Google is
going to play major role in Mobile applications because as it is an open source and it is also
easy to develop mobile applications using Android.
We have tried to the best of our efforts to develop with in limited means. We have
tried to cover all the aspects in "Kuvempu University" app. We expect our project is received
satisfactorily as an encouragement to develop it in a more effective manner.
The goals that have been achieved by the developed application are,
 The student can easily get to know the available PG courses.
 Improved browsing time and browsing experience.
 Providing the academic and campus view of the university via the photo gallery.
 Kuvempu university over the google map.
 Scholarship information and education loans for the students.
 The students can get direct access to results and examination information.
There is no denial to the fact that today's possibilities are not tomorrow's
guarantees. As time evolves, requirements will need to be given a new looking.
Future implementation we can do on this project is:
 Providing the registration facility for students as well as staff.
 Improving the UI.
 Providing the course names with their department profile.
 Giving the notifications of events.
 Providing the street view of Kuvempu university.

BOOKS REFERRED
ANDROID PROGRAMMING TUTORIALS
By Mark L. Murphy
ANDROID TUTORIAL
Simply Easy Learning by tutorialspoint.com
SITES REFERRED
http://www.tutorialspoint.com/android
http://collegedunia.com/university/25615-kuvempu-university-ku-shimoga
https://www.youtube.com/watch?v=SUOWNXGRc6g&list=PL2F07DBCDCC01493A
https://www.youtube.com/watch?v=QAbQgLGKd3Y&list=PL6gx4Cwl9DGBsvRxJJOzG4r4
k_zLKrnxl
https://www.youtube.com/watch?v=EknEIzswvC0&list=PLS1QulWo1RIbb1cYyzZpLFCKv
dYV_yJ-E

University android app

More Related Content

What's hot

Viewers also liked

Similar to University android app

Recently uploaded

University android app