1.

INTRODUCTION :

The Healthcare Android Application is an innovative mobile solution aimed at transforming the
healthcare ecosystem by leveraging the power of modern technology. Developed using Java and
SQLiteDB, the application serves as a bridge between healthcare providers and patients, offering an
all-encompassing platform to manage and access healthcare services effectively.

In today's fast-paced world, the demand for convenient and accessible healthcare solutions has grown
exponentially. Traditional systems often face challenges such as time-consuming appointment
scheduling, limited access to medical records, and inefficiencies in medicine delivery. This application
addresses these issues by offering a seamless, user-friendly interface that combines multiple healthcare
services under one roof.

The application provides a variety of features, including appointment booking, where users can
schedule consultations with healthcare professionals at their convenience. Additionally, the medicine
purchase feature allows users to order medicines directly through the app, minimizing the need for
physical visits to pharmacies. Another noteworthy feature is the integration of health record
management, enabling users to store, track, and share their medical history securely with healthcare
providers.

Whether it's booking an appointment, purchasing essential medicines, or maintaining a comprehensive

health record, the Healthcare Android Application is designed to simplify and enhance the healthcare
journey of every user.

pg. 1
1.1 Existing System and Need for System :

Existing System

In the current healthcare landscape, most services operate in silos, leading to inefficiencies and user
frustration. The existing system is heavily reliant on traditional methods for managing healthcare
services, such as manual appointment booking, in-person visits to pharmacies, and paper-based
medical records. These systems often suffer from the following drawbacks:

1. Time-Consuming Processes: Scheduling appointments requires patients to physically visit

clinics or call during limited hours, leading to long waiting times.
2. Limited Access to Medical Records: Paper-based records are prone to loss, damage, or
misplacement, making it difficult to access critical health information during emergencies.
3. Pharmacy Dependence: Patients often need to visit multiple pharmacies to find prescribed
medicines, resulting in delays and inconvenience.
4. Lack of Integration: The absence of a unified platform means patients must interact with
multiple systems or providers, leading to fragmented healthcare experiences.
5. Geographic Constraints: Many patients, especially those in remote or rural areas, struggle to
access timely healthcare services due to location barriers.

Need for the System

The challenges posed by the existing system highlight the urgent need for a comprehensive,
technology-driven solution that streamlines healthcare services while enhancing accessibility and
convenience. The Healthcare Android Application addresses these pain points through its integrated
features and user-friendly design.

1. Efficient Appointment Management: The system enables users to book appointments with
healthcare professionals at their convenience, eliminating the need for physical visits or long
waits.
2. Secure Digital Records: By providing a centralized repository for storing and accessing
medical records, the application ensures that critical health information is always available
when needed.
3. Convenient Medicine Ordering: Users can order medicines directly through the app, reducing
dependency on physical pharmacies and ensuring timely delivery.
4. Improved Accessibility: The application bridges the gap between patients and healthcare
providers, especially for individuals in remote locations, enabling better healthcare outcomes.

pg. 2
1.2 Scope of system :

The Healthcare Android Application is designed to provide a comprehensive and scalable platform
for managing healthcare services. Its scope extends across various facets of healthcare, aiming to
enhance user experience, improve service delivery, and foster greater accessibility. Below are the key
areas defining the scope of the system:

Functional Scope

1. Appointment Booking:
o Allows users to browse available healthcare professionals and schedule appointments
based on their preferences.
o Provides notifications and reminders to ensure users don’t miss their appointments.
o Facilitates cancellation or rescheduling of appointments.
2. Medicine Purchase:
o Enables users to search for prescribed medicines and place orders directly through the
app.
o Supports online payments and provides order tracking features.
o Integrates with local pharmacies for timely delivery of medicines.
3. Health Record Management:
o Offers a secure digital repository for storing users’ medical history, prescriptions, and
diagnostic reports.
o Allows users to share records with healthcare providers during consultations.
o Provides data backup and recovery options to ensure no loss of critical information.
4. User Management:
o Includes role-based access for patients, doctors, and administrators.
o Supports user registration, login, and profile management functionalities.

Technical Scope

1. Scalability:
o Designed to accommodate a growing number of users and data without performance
degradation.
o Can be extended to include new features such as teleconsultations or fitness tracking.
2. Integration:
o Easily integrates with third-party systems like payment gateways, pharmacy networks,
and wearable health devices.
o Can be adapted to connect with electronic health record (EHR) systems for enhanced
data interoperability.
3. Cross-Platform Compatibility:
o While currently built for Android, the system architecture can be adapted for other
platforms like iOS or web-based interfaces.

Geographical and Market Scope

1. Target Audience:

pg. 3
 o
Primarily caters to patients seeking better access to healthcare services, healthcare
professionals looking to streamline operations, and pharmacies aiming to expand their
customer reach.
2. Urban and Rural Reach:
o Provides urban users with convenience and rural users with access to healthcare
services that might otherwise be unavailable.

Future Scope

1. Teleconsultation Services:
o Integration of video conferencing for remote consultations with doctors.
2. AI-Driven Health Insights:
o Use of artificial intelligence to provide personalized health recommendations and early
detection of potential health issues.
3. Wearable Integration:
o Synchronization with fitness trackers and smartwatches to monitor health metrics such
as heart rate, blood pressure, and activity levels.
4. Insurance Integration:
o Features to manage and claim health insurance directly through the app.

1.3 Operating Environment – Hardware and Software :

1.1 Hardware Requirements

• Processor: A multi-core processor (Intel i5 or equivalent).

• RAM: 8 GB or more to ensure smooth app operation.

• Storage: Minimum 256 GB SSD for efficient development and testing.

• Graphics: Integrated graphics are sufficient, but a dedicated GPU may be useful for
high-resolution UI testing

1.2 Software Requirements

• Operating System: Android OS for mobile deployment and compatibility testing.

• IDE: Android Studio for development.

• Programming Language: Java for backend and XML for frontend.

• Database: Firebase for data management.

• Tools and Libraries: Gradle for build automation, Android SDK for development, and
Google APIs for additional integrations.

• Version Control: Git for code management and collaboration

pg. 4
2. PROPOSED SYSTEM:

2.1 Feasibility Study:

A feasibility study is conducted to ensure the successful development and implementation of the
proposed Healthcare Android Application. It examines the project’s technical, economic, and
operational viability to assess its practicality and potential benefits.

1. Technical Feasibility

• Technology Stack: The proposed system uses well-established and widely adopted
technologies, including Java for development, Android SDK, and Firebase for database
management. These technologies ensure reliability, scalability, and compatibility with modern
devices.
• Platform Compatibility: The application is designed for Android OS, which has a significant
market share, making it accessible to a broad audience.
• Infrastructure Requirements: The development can be supported using mid-range hardware
(Intel i5 processors, 8 GB RAM), ensuring cost-effective implementation.
• Ease of Integration: The system can integrate with third-party APIs such as Google APIs,
Firebase Analytics, and payment gateways, providing advanced functionalities with minimal
complexity.

2. Economic Feasibility

• Development Cost:
o Hardware and software requirements are affordable, with no need for specialized
equipment.
o Open-source tools and libraries, such as Android Studio, Gradle, and Git, significantly
reduce development costs.
• Return on Investment (ROI):
o Revenue streams can be generated through in-app purchases, subscriptions, or
advertising.
o The app’s potential to streamline healthcare processes will save costs for users and
healthcare providers alike.
• Cost of Maintenance:
pg. 5
 o Regular updates and bug fixes require minimal investment due to the system's modular
design.

3. Operational Feasibility

• Ease of Use: The app is designed with a user-friendly interface, ensuring that users of all age
groups, including those with limited technical knowledge, can navigate it easily.
• Training and Deployment:
o Minimal training is required for administrators or healthcare professionals.
o Deployment involves app store distribution, making the system widely available
without physical infrastructure.
• Demand and Adoption:
o Increasing reliance on digital solutions in healthcare and the growing penetration of
smartphones ensure a ready market for the application.
o The app addresses real-world problems such as appointment delays, medicine
unavailability, and poor record management, driving its adoption.

2.2 Objectives of Proposed System:

The primary objectives of the proposed Healthcare Android Application are as follows:

1. Streamline Healthcare Services

o Provide a centralized platform for users to access essential healthcare services, such as
appointment booking, medicine ordering, and health record management.
2. Enhance Accessibility
o Bridge the gap between patients and healthcare providers, ensuring that users, including
those in remote or underserved areas, can access timely and reliable healthcare services.
3. Improve User Convenience
o Design an intuitive and user-friendly interface to make healthcare management easy for
users of all age groups and technical proficiency levels.
4. Enable Digital Health Records
o Offer a secure and organized digital repository for storing and accessing medical
records, prescriptions, and diagnostic reports, ensuring data is readily available during
emergencies.
5. Facilitate Real-Time Communication
pg. 6
 o Implement real-time notifications and reminders for appointments, medicine orders,
and health updates to keep users informed and reduce missed engagements.
6. Ensure Data Security and Privacy
o Utilize robust authentication mechanisms and secure data storage to protect sensitive
user information and comply with data protection regulations.
7. Promote Scalability and Integration
o Build a flexible architecture that supports future enhancements, such as
teleconsultations, wearable device integration, and insurance claims management.
8. Save Time and Resources
o Reduce the need for physical visits to healthcare providers or pharmacies, saving time
and effort for both patients and providers.
9. Support Healthcare Providers
o Assist doctors and administrators by automating routine tasks, managing patient data,
and facilitating efficient appointment scheduling.
10. Encourage Digital Adoption in Healthcare
o Contribute to the digital transformation of the healthcare industry by providing an
innovative solution tailored to modern needs and expectations

2.3 Users of System:

The proposed Healthcare Android Application is designed to cater to a diverse set of users,
each with specific needs and roles within the healthcare ecosystem. The primary users of the
system are as follows:

1. Patients

• Role: End-users who seek healthcare services such as booking appointments, ordering
medicines, and managing their health records.
• Key Benefits:
o Convenient access to healthcare services from their smartphones.
o Secure storage and retrieval of medical history and prescriptions.
o Notifications and reminders for appointments and medicine deliveries.
o Reduced waiting times and travel requirements.

2. Doctors/Healthcare Professionals

• Role: Providers of medical services who manage consultations, appointments, and

patient interactions through the app.

pg. 7
 • Key Benefits:
o Simplified appointment scheduling and management.
o Access to patients' medical histories for informed decision-making.
o Digital platform for organizing and tracking consultations.
o Increased visibility and reach to a larger patient base.

3. Pharmacists

• Role: Suppliers of medicines who fulfill online orders placed by patients.

• Key Benefits:
o Streamlined management of medicine inventory and orders.
o Improved customer reach through the digital platform.
o Enhanced operational efficiency with order tracking and delivery management.

pg. 8
3. ANALYSIS AND DESIGN:

3.1 System Requirements ( Functional and Non Functional Requirements ):

Functional Requirements

These are the features and functionalities the system must provide to meet user needs:

1. User Registration and Authentication

o The system should allow patients, doctors, and administrators to register and
authenticate using secure login credentials (username/password, email, or mobile
verification).
o Role-based access control to differentiate between the types of users (patients, doctors,
administrators).
2. Appointment Booking and Management
o Users (patients) should be able to view available doctors and book appointments based
on date, time, and specialization.
o Users should be able to reschedule or cancel appointments and receive
notifications/reminders.
o Doctors should have the ability to manage their appointment slots and view booked
consultations.
3. Medicine Order and Management
o Patients should be able to search for and order prescribed medicines from integrated
pharmacies.
o Pharmacists should be able to receive, process, and confirm medicine orders, including
delivery tracking.
o Integration of payment gateways to facilitate secure transactions for medicine
purchases.
4. Health Record Management
o Patients should be able to store, update, and view their medical records, prescriptions,
and reports in a digital format.
o Doctors should have access to relevant patient medical history during consultations.
o Users should have the option to share their medical records with healthcare providers
securely.
5. Notifications and Reminders
o The system should send push notifications and reminders for upcoming appointments,
medicine deliveries, and health check-ups.

pg. 9
 6. Search Functionality
o Patients should be able to search for doctors, specialists, or pharmacies based on
location, specialization, or medicine availability.
7. Data Backup and Recovery
o The system should implement data backup mechanisms to ensure that all user data,
medical records, and transactions are stored securely and can be recovered in case of a
system failure.

Non-Functional Requirements

These are the system attributes related to performance, usability, and reliability that ensure the quality
and user experience of the system:

1. Performance
o The system should handle up to 10,000 concurrent users without significant
degradation in performance.
o Response time for booking an appointment, ordering medicines, or retrieving health
records should be under 3 seconds.
2. Scalability
o The system must be designed to scale easily with the addition of more users, healthcare
providers, and pharmacies, without requiring major redesigns.
o The architecture should support future expansion, including features like
teleconsultations, wearable health device integration, and insurance claims
management.
3. Security
o All sensitive data (such as personal health records, medical history, and payment
information) should be encrypted both in transit and at rest using strong encryption
protocols.
o The system should comply with relevant data protection regulations (e.g., GDPR,
HIPAA) to ensure the privacy of user data.
o Secure authentication mechanisms, such as two-factor authentication (2FA) or
biometric login, should be implemented.
4. Usability
o The user interface should be intuitive and easy to navigate, ensuring that users of all
age groups and technical proficiency levels can interact with the system without
difficulty.
pg. 10
 o The application should be mobile-optimized for a smooth experience on smartphones
and tablets.
5. Reliability
o The system should have an uptime of 99.9%, ensuring that healthcare services are
always available when needed.
o The application should be fault-tolerant, with automatic recovery mechanisms in place
to handle minor system failures or crashes.
6. Compatibility
o The application should be compatible with Android versions 6.0 (Marshmallow) and
above to ensure widespread adoption.
o The app should also function seamlessly on a variety of devices with different screen
sizes, resolutions, and hardware capabilities.
7. Maintainability
o The system’s codebase should be modular and well-documented to facilitate easy
maintenance, updates, and bug fixes.
o The application should support over-the-air updates to deliver new features and security
patches without requiring users to reinstall the app.
8. Localization and Internationalization
o The system should support multiple languages, allowing it to be adapted for users from
different regions or countries.
o It should also be able to accommodate different healthcare standards and regulatory
requirements based on geographic location.

pg. 11
3.2 ENTITY REALTIONSHIP DIAGRAM:

pg. 12
3.3 Table Structure:

1. USER Table

Column Name Data Type Constraints Description

username VARCHAR PRIMARY KEY Unique identifier for user
email VARCHAR NOT NULL Email address of the user
password VARCHAR NOT NULL Password for user login

2. LABTEST Table

Column Name Data Type Constraints Description

test_name VARCHAR PRIMARY KEY Unique name of the lab
test
details TEXT NOT NULL Details about the lab test
total_cost FLOAT NOT NULL Total cost for the lab test

pg. 13
3. ORDER Table

Column Name Data Type Constraints Description Column Name

order_id VARCHAR PRIMARY KEY Unique identifier order_id
for the order
username VARCHAR FOREIGN KEY User who placed username
the order
(references USER)
test_name VARCHAR FOREIGN KEY Name of the lab test_name
test (references
LABTEST)
customer_name VARCHAR NOT NULL Name of the customer_name
customer who
placed the order
address TEXT NOT NULL Delivery address address
for the order
contact VARCHAR NOT NULL Contact number of contact
the customer
pincode INT NOT NULL Pincode of the pincode
customer’s address
order_date DATE NOT NULL Date when the order_date
order was placed
order_time TIME NOT NULL Time when the order_time
order was placed
price FLOAT NOT NULL Total price of the price
order
category VARCHAR NOT NULL Category of the category
product (lab in this
case)

4. CART Table

Column Name Data Type Constraints Description

cart_id VARCHAR PRIMARY KEY Unique identifier for the
cart entry
username VARCHAR FOREIGN KEY User who added the
product to the cart
(references USER)
test_name VARCHAR FOREIGN KEY Name of the lab test added
to the cart (references
LABTEST)
price FLOAT NOT NULL Price of the lab test added
to the cart
category VARCHAR NOT NULL Category of the product
(lab in this case)

pg. 14
3.4 Use Case Diagram

pg. 15
3.5 Class Diagram :

pg. 16
3.6 Activity Diagram:

pg. 17
3.7 Deployment Diagram :

pg. 18
3.8 Sample Input And Output Screens:

1.User Registration & Login :

pg. 19
2. Dash Board & Doctor Details Page :

pg. 20
3.(Labtest & Package ) & (Full Body Checkup Page) :

pg. 21
4.Buy Medicine & the capsule Uprise-D3

pg. 22
5.Health articles & Order Details :

pg. 23
4. ANALYSIS AND DESIGN:
4.1 Algorithm(if any):
4.2 Coding:
package com.example.healthcare;

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

public class RegisterActivity extends AppCompatActivity {

EditText edUsername, edPassword, edEmail,edConfirm;

Button btn;
TextView tv;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_register);

edUsername = findViewById(R.id.editTextLTDFullname);
edPassword = findViewById(R.id.editTextLTDPincode);
edEmail = findViewById(R.id.editTextLTDAddress);
edConfirm = findViewById(R.id.editTextLTDContact);
btn = findViewById(R.id.buttonLTDBooking);
tv = findViewById(R.id.textViewExistingUser);

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

}
});

btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
String username = edUsername.getText().toString();
String email = edEmail.getText().toString();
String password = edPassword.getText().toString();
String confirm = edConfirm.getText().toString();
Database db = new
Database(getApplicationContext(),"healthcare",null,1);
if (username.length()==0|| password.length()==0){
Toast.makeText(getApplicationContext(), "Please Fill All Details",
Toast.LENGTH_SHORT).show();

}
else{
if (password.compareTo(confirm)==0){
if (isValid(password)){
db.register(username, email, password);
Toast.makeText(getApplicationContext(), "Record Inserted",
Toast.LENGTH_SHORT).show();
startActivity(new Intent(RegisterActivity.this,
LoginActivity.class));
}

pg. 24
 else{
Toast.makeText(getApplicationContext(), "Password must
contain at least 8 characters, having letter, digit and Special symbol",
Toast.LENGTH_SHORT).show();
}
}
else{
Toast.makeText(getApplicationContext(), "Password and Confirm
Password didn't match", Toast.LENGTH_SHORT).show();
}
}
}
});

}
public static boolean isValid(String passwordhere){
int f1=0,f2=0,f3=0;
if (passwordhere.length() < 8){
return false;
}
else {
for (int p = 0; p < passwordhere.length(); p++){
if (Character.isLetter(passwordhere.charAt(p))){
f1=1;
}
}
for (int r = 0; r < passwordhere.length(); r++){
if (Character.isDigit(passwordhere.charAt(r))){
f2=1;
}
}
for (int s = 0; s < passwordhere.length(); s++){
char c = passwordhere.charAt(s);
if (c>=33&&c<=46||c==64){
f3=1;
}
}
if (f1==1 && f2==1 && f3==1){
return true;
}
return false;
}
}
}

package com.example.healthcare;

import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

public class LoginActivity extends AppCompatActivity {

EditText edUsername, edPassword;
Button btn;
TextView tv;

pg. 25
 @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);

edPassword = findViewById(R.id.editTextLoginPassword);
edUsername = findViewById(R.id.editTextLoginUsername);
btn = findViewById(R.id.buttonLogin);
tv = findViewById(R.id.textViewNewUSer);

btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
// startActivity(new Intent(LoginActivity.this,HomeActivity.class));
String username = edUsername.getText().toString();
String password = edPassword.getText().toString();
Database db = new
Database(getApplicationContext(),"healthcare",null,1);
if (username.length()==0|| password.length()==0){
Toast.makeText(getApplicationContext(), "Please Fill All Details",
Toast.LENGTH_SHORT).show();
}
else{
if (db.login(username,password)==1){
Toast.makeText(getApplicationContext(), "Login Success",
Toast.LENGTH_SHORT).show();
SharedPreferences sharedpreferences =
getSharedPreferences("shared_prefs",Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedpreferences.edit();
editor.putString("username",username);
editor.apply();
startActivity(new
Intent(LoginActivity.this,HomeActivity.class));
}
else{
Toast.makeText(getApplicationContext(), "Invalid Username and
Password", Toast.LENGTH_SHORT).show();

}
}
}
});

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

}
}

package com.example.healthcare;

pg. 26
import android.content.Intent;
import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.CardView;
import android.view.View;

public class FindDoctorActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_find_doctor);

CardView exit = findViewById(R.id.cardFDBack);

exit.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(FindDoctorActivity.this,HomeActivity.class));
}
});

CardView familyphysician = findViewById(R.id.cardFDFamilyPhysician);

familyphysician.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent it = new
Intent(FindDoctorActivity.this,DoctorDetailsActivity.class);
it.putExtra("title","Family Physician");
startActivity(it);
}
});
CardView dietician = findViewById(R.id.cardFDDietician);
dietician.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent it = new
Intent(FindDoctorActivity.this,DoctorDetailsActivity.class);
it.putExtra("title","Dietecian");
startActivity(it);
}
});
CardView dentist = findViewById(R.id.cardFDDentist);
dentist.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent it = new
Intent(FindDoctorActivity.this,DoctorDetailsActivity.class);
it.putExtra("title","Dentist");
startActivity(it);
}
});
CardView surgeon = findViewById(R.id.cardFDSurgeon);
surgeon.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent it = new
Intent(FindDoctorActivity.this,DoctorDetailsActivity.class);
it.putExtra("title","Surgeon");
startActivity(it);
}
});
CardView cardiologist = findViewById(R.id.cardFDCardiologist);
cardiologist.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {

pg. 27
 Intent it = new
Intent(FindDoctorActivity.this,DoctorDetailsActivity.class);
it.putExtra("title","Cardiologist");
startActivity(it);
}
});
}
}

package com.example.healthcare;

import android.app.AlertDialog;
import android.app.DatePickerDialog;
import android.app.TimePickerDialog;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.DatePicker;
import android.widget.ListView;
import android.widget.SimpleAdapter;
import android.widget.TextView;
import android.widget.TimePicker;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;

public class CartLabActivity extends AppCompatActivity {

HashMap<String,String> item;
ArrayList list;
ListView lst;
SimpleAdapter sa;
TextView tvTotal;
private String[][] packages = {};
private DatePickerDialog datePickerDialog;
private TimePickerDialog timePickerDialog;
Button dateButton, timeButton, btnCheckout, btnBack;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_cart_lab);

dateButton = findViewById(R.id.buttonCartDates);
timeButton = findViewById(R.id.buttonCartTime);
btnCheckout = findViewById(R.id.buttonCartCheckout);
btnBack = findViewById(R.id.buttonCartBack);
tvTotal = findViewById(R.id.textViewCartotalPrice);
lst = findViewById(R.id.listViewCart);

SharedPreferences sharedPreferences = getSharedPreferences("shared_prefs",

Context.MODE_PRIVATE);

pg. 28
 String username = sharedPreferences.getString("username","").toString();

Database db = new Database(getApplicationContext(),"healthcare",null,1);

float totalAmount = 0;
ArrayList dbData = db.getCartData(username,"lab");
//Toast.makeText(this, ""+dbData, Toast.LENGTH_LONG).show();

packages = new String[dbData.size()][];

for (int i = 0;i<packages.length;i++){
packages[i]= new String[5];
}

for (int i=0;i<dbData.size();i++){

String arrData = dbData.get(i).toString();
String[] strData = arrData.split(java.util.regex.Pattern.quote("$"));
packages[i][0]= strData[0];
packages[i][4]= "Cost : "+strData[1]+"/-";
totalAmount = totalAmount + Float.parseFloat(strData[1]);
}
tvTotal.setText("Total Cost : "+totalAmount);

list = new ArrayList();

for(int i = 0;i<packages.length;i++ ){
item= new HashMap<String,String>();
item.put("line1",packages[i][0]);
item.put("line2",packages[i][1]);
item.put("line3",packages[i][2]);
item.put("line4",packages[i][3]);
item.put("line5",packages[i][4]);
list.add(item);
}
sa = new SimpleAdapter(this, list, R.layout.multi_lines,
new String[]{"line1", "line2", "line3", "line4", "line5"},
new int[]{R.id.line_a, R.id.line_b, R.id.line_c, R.id.line_d,
R.id.line_e,});
lst.setAdapter(sa);

btnBack.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
startActivity(new Intent(CartLabActivity.this,LabTestActivity.class));

}
});
btnCheckout.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent it = new Intent(new
Intent(CartLabActivity.this,LabTestBookActivity.class));
it.putExtra("price",tvTotal.getText());
it.putExtra("date",dateButton.getText());
it.putExtra("time",timeButton.getText());
startActivity(it);
}
});

//datepicker
initDatePicker();
dateButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
datePickerDialog.show();
}
});
//timepicker
initTimePicker();

pg. 29
 timeButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
timePickerDialog.show();
}
});
}
private void initDatePicker(){
DatePickerDialog.OnDateSetListener dateSetListener= new
DatePickerDialog.OnDateSetListener() {
@Override
public void onDateSet(DatePicker datePicker, int i, int i1, int i2) {
i1 = i1+1;
dateButton.setText(i2+"/"+i1+"/"+i);
}
};
Calendar cal = Calendar.getInstance();
int year= cal.get(Calendar.YEAR);
int month= cal.get(Calendar.MONTH);
int day= cal.get(Calendar.DAY_OF_MONTH);

int style = AlertDialog.THEME_HOLO_DARK;

datePickerDialog = new
DatePickerDialog(this,style,dateSetListener,year,month,day);
datePickerDialog.getDatePicker().setMinDate(cal.getTimeInMillis()+86400000);
}
private void initTimePicker(){
TimePickerDialog.OnTimeSetListener timeSetListener = new
TimePickerDialog.OnTimeSetListener() {
@Override
public void onTimeSet(TimePicker timePicker, int i, int i1) {
timeButton.setText(i+":"+i1);
}
};
Calendar cal = Calendar.getInstance();
int hrs= cal.get(Calendar.HOUR);
int mins= cal.get(Calendar.MINUTE);

int style = AlertDialog.THEME_HOLO_DARK;

timePickerDialog = new
TimePickerDialog(this,style,timeSetListener,hrs,mins,true);

}
}

package com.example.healthcare;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}

pg. 30
5 TESTING :

5.1 Testing Strategy:

The testing strategy for the Healthcare Android Application focuses on ensuring the reliability,
functionality, performance, and security of the system. A combination of manual and automated testing
techniques is used to identify and resolve defects effectively. The strategy involves different types of
testing to validate the application at every stage of development.

Testing Approach:

1. Unit Testing:
o Purpose: To validate the functionality of individual components and modules.
o Scope: Testing key modules such as user registration, appointment booking, and
medicine ordering.
o Tools: JUnit for Java-based unit testing.
2. Integration Testing:
o Purpose: To ensure that individual components work together as expected.
o Scope: Testing the integration between the backend (Java), frontend (XML), and the
Firebase database.
o Example: Verify that appointment data entered by the user is correctly stored and
retrieved from the database.
3. System Testing:
o Purpose: To evaluate the system as a whole, ensuring that all modules function together.
o Scope: Testing the application’s overall functionality, including user authentication,
appointment booking, notifications, and medicine order tracking.
o Tools: Android Studio Emulator for testing on various Android versions.
4. User Acceptance Testing (UAT):
o Purpose: To ensure the system meets user requirements and expectations.
o Scope: Conducting testing sessions with real users (patients, doctors, and pharmacists)
to validate usability and functionality.
o Deliverable: Feedback for refinements before deployment.
5. Performance Testing:
o Purpose: To assess the application’s speed, responsiveness, and stability under load.
o Scope: Simulating up to 10,000 concurrent users to ensure scalability.
o Tools: JMeter for load testing.
pg. 31
6. Security Testing:
o Purpose: To identify vulnerabilities and ensure the protection of sensitive data.
o Scope: Testing for secure data storage, prevention of SQL injection, and secure user
authentication mechanisms.
o Tools: OWASP ZAP for security analysis.
7. Regression Testing:
o Purpose: To verify that new changes do not negatively impact existing functionalities.
o Scope: Running automated test scripts after updates or bug fixes.
o Tools: Selenium for automated regression testing.
8. Compatibility Testing:
o Purpose: To ensure compatibility across different devices, screen sizes, and Android
OS versions.
o Scope: Testing the app on devices with various resolutions and operating systems
(Android 6.0 and above).

pg. 32
5.2 Unit Test Plan :

Unit Test Plan for Healthcare Android Application

The Unit Test Plan outlines the approach to testing individual components of the Healthcare Android
Application. It aims to validate that each unit of the codebase, such as functions, methods, and classes,
performs as expected in isolation. This test plan focuses on both the frontend (XML-based UI) and
backend (Java and Firebase integration).

1. Objectives

• Verify that individual units (functions, methods, components) of the application perform as
expected.
• Ensure that each component handles valid and invalid inputs correctly.
• Identify and fix bugs early in the development process.
• Achieve high code coverage to improve reliability and maintainability.

2. Scope

Frontend (Android XML UI):

• Unit testing of UI components like buttons, forms, list views, and API interactions.
• Validation of data bindings and UI responsiveness across devices.

Backend (Java with Firebase):

• Unit testing of service classes, database operations, and RESTful API interactions.
• Validation of business logic, such as appointment booking, authentication, and order
processing.

3. Test Environment

Frontend:

• Android Studio environment with JUnit for Android unit testing.

pg. 33
 • Use of Espresso for UI interaction testing.

Backend:

• Java environment with JUnit 5 and Mockito for mocking dependencies.

• Firebase Emulator Suite for testing database interactions and authentication flows.

4. Tools & Frameworks

Frontend:

• Testing Framework: JUnit (for unit tests).

• UI Testing: Espresso (for functional UI tests).
• Mocking: Mockito (for mocking API requests and services).

Backend:

• Testing Framework: JUnit 5 (for unit testing).

• Mocking Framework: Mockito (to mock Firebase and other services).
• Firebase Emulator: For testing authentication, database, and Firestore operations.

pg. 34
5.3 Acceptance Test Plan:

Objective

The objective of acceptance testing is to confirm that the system functions as intended and is ready for
deployment. It ensures that all user requirements are met, and the application provides a seamless user
experience.

Scope

The acceptance tests cover all critical functionalities, including:

• User registration and authentication.

• Appointment booking and management.
• Prescription generation and retrieval.
• Medicine ordering and pharmacy integration.
• Notifications and reminders for appointments and medicine orders.

Testing Approach

1. Requirement Validation:

Each feature and functionality is tested against the original requirements to ensure completeness and
correctness.

2. Real-World Scenarios:

Test cases are designed to replicate actual user scenarios, such as booking an appointment with a
specific doctor or ordering medicines with multiple items.

3. User Role Testing:

Different user roles (patient, doctor, administrator) are tested to validate access permissions and role-
specific functionalities.

pg. 35
Acceptance Criteria

• Functional Correctness: All features must work as expected without errors.

• Performance: The application must respond within acceptable time limits under normal and
peak loads.
• Usability: The application must be intuitive and user-friendly for all types of users.
• Data Integrity: Information such as user details, appointments, and prescriptions must be
accurate and consistent.
• Security: Sensitive user data must be securely stored and transmitted, with proper
authentication and authorization mechanisms in place.

Testing Environment

• Real devices with various Android OS versions (6.0 and above).

• Different screen sizes and resolutions to ensure compatibility.
• Firebase Emulator Suite to replicate backend functionalities during testing.

Deliverables

• A detailed test report documenting the results of all test cases.

• A list of issues identified during testing with their resolutions.
• Approval from stakeholders (end-users, project team, and management) before deployment.

pg. 36
5.4 Test Case:

1. User Registration and Authentication :

Test Case ID Component Test Description Input Expected Output

UR-01 User Validate successful Name, Email, User registered successfully
Registration registration with Password
valid inputs
UR-02 User Validate error for Empty Email or Error message: "All fields are
Registration missing required Password mandatory"
fields
UR-03 User Login Validate successful Email, User logged in successfully
login with correct Password
credentials
UR-04 User Login Validate error for Email, Invalid Error message: "Invalid
incorrect credentials Password credentials"

2. Appointment Booking

Test Case ID Component Test Description Input Expected Output

AB-01 Appointment Validate successful Patient_ID, Appointment
Booking booking with Doctor_ID, Date, booked
available slot Time successfully
AB-02 Appointment Validate error for Patient_ID, Error message:
Booking booking in Doctor_ID, Date, "Slot unavailable"
unavailable slot Time
AB-03 Appointment Validate successful Appointment_ID Appointment
Cancellation cancellation of an cancelled
appointment successfully
AB-04 Appointment Validate Appointment_ID, Appointment
Rescheduling rescheduling with New Date, New rescheduled
new date and time Time successfully

pg. 37
3.Prescription Management

Test Case ID Component Test Description Input Expected Output

PM-01 Prescription Validate successful Patient_ID, Prescription added
Module addition of a Doctor_ID, successfully
prescription Medicines
PM-02 Prescription Validate retrieval of Patient_ID Prescription details
Module a patient's retrieved
prescription successfully
PM-03 Prescription Validate error for Unauthorized User Error message:
Module unauthorized "Access Denied"
access

4. Medicine Ordering

Test Case ID Component Test Description Input Expected Output

MO-01 Medicine Ordering Validate successful Patient_ID, Order placed
placement of an Medicine_ID, successfully
order Quantity
MO-02 Medicine Ordering Validate error for Medicine_ID, Error message:
ordering Quantity "Out of stock"
unavailable stock
MO-03 Medicine Ordering Validate successful Order_ID Order cancelled
cancellation of an successfully
order

5. Notification

Test Case ID Component Test Description Input Expected Output

UN-01 Notification Module Validate sending Appointment_ID Notification sent
appointment successfully
reminders
UN-02 Notification Module Validate sending Patient_ID, Notification sent
prescription alerts Prescription_ID successfully

6. Admin Management

Test Case ID Component Test Description Input Expected Output

AM-01 Admin Management Validate adding a Doctor Details Doctor added
new doctor to the successfully
system
AM-02 Admin Management Validate removing a Doctor_ID Doctor removed
doctor from the successfully
system
AM-03 Admin Management Validate viewing all None List of patients
registered patients displayed
pg. 38
5.5 Defect report:

• D-001 - User Registration

• Description: When a user tries to register with an email that already exists in the database, the
system does not display an error message.
• Severity: High
• Status: Open
• Steps to Reproduce:
1. Open the registration screen.
2. Enter an email address that is already registered.
3. Attempt to submit the registration form.
• Expected Behavior: The system should notify the user that the email is already taken.

• D-002 - Appointment Booking

• Description: When a user attempts to book an appointment after the clinic's operating hours,
the system fails to display a message indicating that the slot is unavailable.
• Severity: Medium
• Status: Closed
• Steps to Reproduce:
1. Select a doctor and choose a time that falls outside operating hours.
2. Attempt to book the appointment.
• Expected Behavior: A message should be displayed stating that the selected time slot is
unavailable.

• D-003 - Prescription Module

• Description: Prescription details are not saving in the system, causing loss of prescription data
when a user tries to view it later.
• Severity: High
• Status: Open
• Steps to Reproduce:
1. Add prescription details for a patient.
2. Attempt to save the prescription.
3. Close the prescription page and reopen it.
pg. 39
 • Expected Behavior: The prescription details should be saved and retrievable.

• D-004 - Medicine Ordering

• Description: When the stock of a medicine is low, the system does not prevent the user from
ordering it, and an order is placed even though the medicine is unavailable.
• Severity: High
• Status: In Progress
• Steps to Reproduce:
1. Search for a medicine that has limited stock.
2. Attempt to place an order for the medicine.
• Expected Behavior: The system should notify the user that the medicine is out of stock and
prevent the order.

• D-005 - Admin Management

• Description: Admin users cannot remove a doctor from the system due to a UI bug.
• Severity: Low
• Status: Closed
• Steps to Reproduce:
1. Log in as an admin.
2. Attempt to remove a doctor from the doctor management section.
• Expected Behavior: The system should allow the admin to remove the doctor from the system.

pg. 40
6 LIMITATIONS OF PROPOSED SYSTEM:

While the proposed Healthcare Android Application offers a wide range of functionalities for users, it
also has several limitations that need to be considered. These limitations could affect the user
experience or pose challenges in system performance. Below are the key limitations:

1. Internet Dependency

The system relies heavily on an internet connection for features such as real-time appointment booking,
notifications, and data synchronization. Users with limited or no internet access may experience
disruptions in service.

2. Limited Platform Compatibility

Currently, the application is designed for Android OS, limiting its accessibility to users who do not
have Android devices. A cross-platform version (for iOS, for example) is not yet available.

3. Data Privacy and Security Concerns

Though the system uses secure protocols and encryption, concerns around data privacy may arise,
especially in handling sensitive health information. A breach or mishandling of such data could lead
to legal and reputational issues.

4. Device Dependency

The system performance and user experience may vary depending on the device specifications. For
instance, older smartphones with lower hardware capabilities might face performance issues such as
slow loading times or app crashes.

5. Scalability Issues

pg. 41
As the system grows, the current architecture may face challenges in handling a significantly larger
user base. The application may need to scale its backend infrastructure to ensure it can handle
increasing data volumes, especially in terms of medical records, prescriptions, and user data.

6. Limited Language Support

Currently, the system supports only a single language (English), which limits its use for users who
prefer or require services in different languages. Expanding language support could improve
accessibility for a wider audience.

7. Lack of Advanced Features

While the system covers basic functionalities like appointment booking, prescription management, and
notifications, it lacks advanced features such as telemedicine capabilities (video consultations), AI-
based symptom checkers, and integration with health devices (e.g., wearable fitness trackers).

8. Human Error in Data Entry

The accuracy of patient data, appointment details, and prescriptions depends on manual data entry by
users or healthcare providers. This increases the risk of human error, which could lead to incorrect
information being stored or displayed in the system.

9. Limited Doctor Availability

The application may only support a limited number of doctors for booking appointments at any given
time. Users might face difficulty in finding available doctors during peak times, and there could be a
mismatch between doctor availability and the patient's preferred schedule.

pg. 42
7 PROPOSED ENHANCEMENTS:

To improve the functionality, performance, and overall user experience of the Healthcare Android
Application, several enhancements can be introduced in the future. These enhancements will address
the current limitations, provide additional features, and ensure the system is scalable and adaptable to
changing healthcare requirements.

1. Multi-Platform Support

To reach a wider audience, the application can be expanded to support iOS in addition to Android.
This would allow users on different mobile platforms to access healthcare services seamlessly, thus
increasing the app's user base.

2. Integration with Telemedicine

The inclusion of telemedicine features, such as video consultations with doctors, would provide users
with more flexible and convenient healthcare options. Patients could consult doctors remotely,
reducing the need for in-person visits and improving healthcare accessibility.

3. AI-Based Symptom Checker

Integrating an AI-based symptom checker within the app would help users assess their symptoms
before consulting a doctor. This feature could provide preliminary advice based on input from users,
guiding them on whether they need to seek immediate medical attention or if their symptoms can be
managed at home.

4. Multi-Language Support

Expanding the language options within the app would make it more accessible to non-English speaking
users. Including regional languages like Hindi, Marathi, and others would enhance usability and reach
a broader audience, especially in India where multiple languages are spoken.

pg. 43
5. Integration with Health Devices

Future versions of the app could integrate with health devices such as fitness trackers, smartwatches,
and other medical monitoring devices (e.g., blood pressure monitors, glucose meters). This would
allow users to track their health metrics in real-time and share relevant data with doctors for more
accurate diagnoses and personalized treatment plans.

6. Advanced Reporting and Analytics

The application could include advanced reporting and analytics tools for patients and healthcare
providers. Patients could track their health over time through charts and graphs, while doctors could
analyze patient data to improve diagnoses and treatment plans. This feature would make healthcare
data more actionable.

7. Enhanced Security and Privacy Features

To address security concerns, additional features such as multi-factor authentication (MFA) for login,
enhanced encryption for data storage, and more granular access controls for healthcare providers
should be added. This would ensure that sensitive patient information remains secure and compliant
with regulatory standards like HIPAA (in the U.S.) or GDPR (in the EU).

8. Appointment Scheduling with Multiple Doctors

Allowing patients to schedule appointments with multiple doctors or specialists in a single process
would make it easier for patients who need multi-specialty consultations. It would reduce time and
effort in booking separate appointments, providing a more convenient experience.

9. Push Notifications for Health Reminders

Incorporating push notifications for regular health reminders, such as medication schedules, doctor
appointments, and preventive care tasks, could significantly improve patient adherence to prescribed
treatments. This feature could also notify patients of upcoming appointments or availability changes
in the clinic.
pg. 44
10. Chatbot Integration for Support

Introducing an AI-powered chatbot could assist users in getting quick answers to common questions
related to appointments, prescriptions, or general health queries. This would improve user engagement
and offer instant support, especially outside of working hours.

11. Enhanced Doctor-Patient Interaction

Expanding the communication options between doctors and patients would improve the overall user
experience. Features such as in-app messaging, sharing of medical documents (like lab reports), and
video consultations would facilitate better communication and more efficient healthcare delivery.

12. Cloud-Based Backend for Scalability

To ensure the system is capable of handling a growing user base and increasing data volumes,
migrating the backend infrastructure to the cloud (e.g., AWS, Google Cloud) would improve
scalability. This would allow for dynamic resource allocation based on user demand and ensure smooth
performance even with a large number of users.

13. Offline Mode for Limited Connectivity

Introducing an offline mode would allow users to access certain features of the app, such as viewing
past prescriptions or medical history, even when they do not have internet connectivity. Once the
device is back online, the data can be synchronized automatically with the server.

pg. 45
8. Conclusion

The Healthcare Android Application aims to revolutionize the way users interact with healthcare
services by providing a seamless and user-friendly platform for managing appointments, prescriptions,
and other health-related tasks. The application offers an efficient way for patients to connect with
doctors, book appointments, and manage their healthcare needs, while enabling healthcare providers
to streamline their operations.

Despite the impressive set of features, the system does have limitations, such as internet dependency,
limited platform compatibility, and challenges in scalability. However, these limitations can be
addressed with future enhancements such as multi-platform support, telemedicine features, integration
with health devices, and advanced security measures.

Through careful planning, testing, and continuous improvements, the system has the potential to
transform healthcare delivery by making it more accessible, efficient, and personalized. By providing
users with easy access to their health data and enabling more effective communication between
patients and healthcare providers, the application can help improve overall health outcomes and
contribute to the growing trend of digital healthcare solutions.

In conclusion, the Healthcare Android Application serves as an important step toward modernizing
healthcare and improving patient experiences. With future enhancements, it can become a
comprehensive solution for managing healthcare needs in a more holistic and user-centric manner.

pg. 46
9 BIBILOGRPHY:

The following references were used in the development and understanding of the Healthcare Android
Application project:

1. Android Documentation
Android Developers. "Android Developer Guide." https://developer.android.com
Accessed: December 2024.
This official guide provided valuable insights into building Android applications, including user
interface design, data storage, and network operations.
2. Firebase Documentation
Firebase. "Firebase Docs." https://firebase.google.com/docs
Accessed: December 2024.
Firebase's documentation was essential for implementing user authentication, real-time database
management, and push notifications in the app.
3. Spring Boot Documentation
Pivotal Software. "Spring Boot Reference Guide." https://docs.spring.io/spring-
boot/docs/current/reference/html/
Accessed: December 2024.
This reference guide provided crucial information for backend development using Spring Boot,
including setting up REST APIs and service layers.
4. Material Design Guidelines
Google. "Material Design." https://material.io/design
Accessed: December 2024.
The Material Design guidelines helped shape the user interface to ensure a modern, intuitive, and
consistent user experience.
5. JUnit 5 Documentation
JUnit. "JUnit 5 User Guide." https://junit.org/junit5/docs/current/user-guide/
Accessed: December 2024.
JUnit 5 was utilized for unit testing of the backend code, ensuring the reliability and correctness
of the application’s logic.
6. React Native Documentation
Facebook. "React Native Docs." https://reactnative.dev/docs/getting-started
Accessed: December 2024.
React Native’s documentation was referenced for the frontend development of cross-platform
mobile applications and integrating APIs.

pg. 47
7. API Design and Best Practices
Martin, R. (2017). "API Design Patterns." O'Reilly Media.
This book was consulted for best practices in API design, particularly regarding RESTful
services and efficient data management.
8. Books on Software Engineering and Project Management
Sommerville, I. (2011). Software Engineering (9th Edition). Addison-Wesley.
This book provided insights into best practices in software engineering, project management, and
system design, which were applied throughout the project lifecycle.
9. Security Guidelines for Healthcare Applications
HealthIT.gov. "Security and Privacy in Health IT." https://www.healthit.gov/topic/privacy-
security
Accessed: December 2024.
This resource was essential for understanding privacy and security regulations, particularly in
relation to handling patient health information.
10. GDPR Guidelines for Data Protection
European Commission. "General Data Protection Regulation (GDPR)." https://gdpr.eu/
Accessed: December 2024.
The GDPR guidelines were referenced for ensuring that the application adheres to global data
protection standards.

pg. 48
10 USER MANUAL:

1. Introduction

The Healthcare Android Application allows users to book appointments with doctors, manage
prescriptions, access medical history, and receive health notifications. It serves as a comprehensive
tool for both patients and healthcare providers to streamline healthcare services.

2. Getting Started

Installing the App

1. Visit the Google Play Store on your Android device.

2. Search for "Healthcare Application" or use the provided link.
3. Tap on "Install" to download and install the app.
4. Once installed, open the app from your app drawer.

Creating an Account

1. Launch the app and tap on "Sign Up."

2. Enter your personal details, including your name, email address, phone number, and password.
3. Choose your role (Patient or Healthcare Provider).
4. Complete any additional information requested (e.g., medical history for patients).
5. Tap "Register" to create your account.
6. You will receive a confirmation email. Click on the confirmation link to verify your account.

3. User Dashboard

Upon logging in, you will be taken to the User Dashboard. Here, you can see a summary of:

• Upcoming Appointments: A list of your scheduled appointments.

• Prescriptions: A record of past prescriptions.
• Health Notifications: Important health-related reminders.
• Profile: Your personal information and settings.

pg. 49
4. Booking Appointments

To book an appointment:

1. From the Dashboard, tap on "Book Appointment."

2. Select the doctor or healthcare provider from the list of available specialists.
3. Choose an appointment time that suits your schedule.
4. Confirm the appointment details and tap "Book Appointment."
5. You will receive a confirmation notification, and the appointment will appear in your
dashboard.

Canceling or Rescheduling an Appointment

1. Go to the "Upcoming Appointments" section in the Dashboard.

2. Select the appointment you want to cancel or reschedule.
3. Tap on "Cancel" or "Reschedule" and follow the prompts.

5. Managing Prescriptions

To view or manage your prescriptions:

1. Go to the "Prescriptions" section in the Dashboard.

2. Tap on a prescription to view its details.
3. If you need to request a refill, tap "Request Refill" and follow the instructions.

Uploading New Prescriptions

1. If you are a healthcare provider, you can upload prescriptions by selecting "Upload
Prescription" from the menu.
2. Enter the patient's details and prescription information.
3. Tap "Save" to upload the prescription to the patient's record.

6. Viewing Medical History

To view your medical history:

1. Tap on "Medical History" from the Dashboard.

pg. 50
 2. You can browse through past medical records, including appointment details and prescriptions.
3. To view more detailed information, tap on individual records.

7. Settings

In the Settings section, you can:

• Update Profile: Edit personal details such as name, contact information, and password.
• Notification Preferences: Set preferences for receiving reminders and updates (e.g.,
appointment reminders, prescription refills).
• Language Preferences: Change the language of the app (currently supports English).
• Privacy Settings: Manage how your data is shared with healthcare providers.

8. FAQs

Q: What should I do if I forget my password?

A: Tap on "Forgot Password" on the login screen, enter your email address, and follow the
instructions to reset your password.

Q: Can I book an appointment with multiple doctors?

A: Yes, you can book appointments with multiple doctors by repeating the appointment booking
process.

Q: How can I view past prescriptions?

A: You can view your past prescriptions under the "Prescriptions" section in the Dashboard.

9. Contact Support

If you need assistance with the app:

1. Go to the "Settings" menu and select "Contact Support."

2. Fill out the support form with your issue, and our team will respond as soon as possible.
3. Alternatively, you can email support at: [email protected].

pg. 51