Docsity
Docsity
Prepare for your exams
Prepare for your exams

Study with the several resources on Docsity

Earn points to download
Earn points to download

Earn points by helping other students or get them with a premium plan

Guidelines and tips
Guidelines and tips
Sell on Docsity
Sell on Docsity
Docsity AI
Docsity AI
Log inSign up

Prepare for your exams

Study with the several resources on Docsity

Find documents

Prepare for your exams with the study notes shared by other students like you on Docsity

Search for your university

Find the specific documents for your university's exams

Docsity AINEW

Summarize your documents, ask them questions, convert them into quizzes and concept maps

Explore questions

Clear up your doubts by reading the answers to questions asked by your fellow students

Earn points to download

Earn points by helping other students or get them with a premium plan

Share documents
download point icon20 Points

For each uploaded document

Answer questions
download point icon5 Points

For each given answer (max 1 per day)

All the ways to get free points
Get points immediately

Choose a premium plan with all the points you need

Study Opportunities

Choose your next study program

Get in touch with the best universities in the world. Search through thousands of universities and official partners

Community

Ask the community

Ask the community for help and clear up your study doubts

Free resources

Our save-the-student-ebooks!

Download our free guides on studying techniques, anxiety management strategies, and thesis advice from Docsity tutors

SCI/ICT/1269/22 Mobile Application Development Assignment 2026/2027, Exams of Computer Science

Johns Hopkins University (JHU)Computer Science

SCI/ICT/1269/22 Mobile Application Development Assignment 2026/2027 1."Material design guidelines" in mobile application development by Google and "Human interface Guidelines" by Apple.Check on the Topics:Best practices for UI /UX design and using XML in Android and SwiftUI in iOS. Then design a simple user interface using figma or sketch for a banking app Best Practices for UI/UX Design Google’s Material Design Guidelines (Android) and Apple’s Human Interface Guidelines (iOS) both focus on the following principles to ensure a cohesive and user-friendly experience: 1. Consistency • Material Design emphasizes consistency in the layout, color scheme, typography, and iconography. Consistent elements across different screens help users understand how to interact with the app.

Typology: Exams

2025/2026

Available from 02/27/2026

ProExamSolutions
ProExamSolutions 🇺🇸

369 documents

1 / 52

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
1
SCI/ICT/1269/22
Mobile Application Development Assignment 2026/2027
1."Material design guidelines" in mobile application development by Google and
"Human interface Guidelines" by Apple.Check on the Topics:Best practices for UI
/UX design and using XML in Android and SwiftUI in iOS. Then design a simple user
interface using figma or sketch for a banking app
Best Practices for UI/UX Design
Google’s Material Design Guidelines (Android) and Apple’s Human Interface Guidelines
(iOS) both focus on the following principles to ensure a cohesive and user-friendly experience:
1. Consistency
• Material Design emphasizes consistency in the layout, color scheme, typography, and
iconography. Consistent elements across different screens help users understand how to
interact with the app.
• Human Interface Guidelines focus on consistent user experience through the use of
system-wide elements such as buttons, tab bars, and navigation controls. iOS apps should
follow native design patterns to provide seamless integration with iOS conventions.
2. Simplicity • Material Design encourages clean, uncluttered designs that emphasize
essential content and controls.
• Apple’s Human Interface Guidelines prioritize simplicity in UI, avoiding complex or
overloaded screens, and allowing for easy navigation.
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e
pf1f
pf20
pf21
pf22
pf23
pf24
pf25
pf26
pf27
pf28
pf29
pf2a
pf2b
pf2c
pf2d
pf2e
pf2f
pf30
pf31
pf32
pf33
pf34

Partial preview of the text

Download SCI/ICT/1269/22 Mobile Application Development Assignment 2026/2027 and more Exams Computer Science in PDF only on Docsity!

SCI/ICT/1269/

Mobile Application Development Assignment 202 6 /202 7

1."Material design guidelines" in mobile application development by Google and

"Human interface Guidelines" by Apple.Check on the Topics:Best practices for UI

/UX design and using XML in Android and SwiftUI in iOS. Then design a simple user

interface using figma or sketch for a banking app

Best Practices for UI/UX Design

Google’s Material Design Guidelines (Android) and Apple’s Human Interface Guidelines

(iOS) both focus on the following principles to ensure a cohesive and user-friendly experience:

1. Consistency

  • Material Design emphasizes consistency in the layout, color scheme, typography, and

iconography. Consistent elements across different screens help users understand how to

interact with the app.

  • Human Interface Guidelines focus on consistent user experience through the use of

system-wide elements such as buttons, tab bars, and navigation controls. iOS apps should

follow native design patterns to provide seamless integration with iOS conventions.

2. Simplicity • Material Design encourages clean, uncluttered designs that emphasize

essential content and controls.

  • Apple’s Human Interface Guidelines prioritize simplicity in UI, avoiding complex or

overloaded screens, and allowing for easy navigation.

3. Accessibility • Both platforms emphasize the importance of designing for accessibility.

Material Design highlights color contrast and provides clear guidelines for color usage and

readable text.

  • Apple ensures that apps are navigable for users with disabilities, including voiceover

functionality, dynamic text sizes, and high contrast options.

4. Responsiveness • Material Design encourages building layouts that adapt to different screen

sizes, using responsive grids and flexible components.

  • iOS encourages auto-layout and size classes to ensure that the UI adapts to different screen

sizes, orientations, and devices (iPhone, iPad).

Using XML in Android (Material Design)

XML (Extensible Markup Language) is used to design UI elements in Android. It is used to

.padding() .frame(maxWidth: .infinity) .background(Color.blue) .cornerRadius(10) } .padding(.top, 24) } .padding(.horizontal, 16) } } struct ContentView_Previews: PreviewProvider { static var previews: some View { ContentView() } }

Designing the Banking App UI Using Figma

I’ll provide the design concept for a banking app in Figma, which includes key UI components that

follow best practices for UI/UX design. These include:

1. Account Balance Section:

o A prominent balance display with a clear, bold font.

o A simple title like "Account Balance" followed by the balance amount.

2. Transfer Button:

o A call-to-action button for transactions, prominently placed below the account

balance.

o Clear label with a bright color (e.g., blue) and rounded corners.

3. Navigation:

o A bottom navigation bar with icons for key actions like Home, Transfers, Settings.

4. Typography: o Use of large, readable fonts for balance and actions, with consistent sizes.

I'll go ahead and generate a simple UI for a banking app in Figma. Let me know if you want me

to proceed with creating the actual design.

2.Discuss clean architecture in software structure and design. Focus on: MVC,

MVVM, and clean architecture for mobile apps and managing activity and

fragment lifecycle in Android. Then create a UML diagram for an e-commerce app

using MVVM architecture

Clean Architecture in Software Structure and Design

Clean Architecture is a concept introduced by Robert C. Martin (Uncle Bob) that focuses on

organizing software in a way that is independent of frameworks, UI, database, and other external

agencies. This separation of concerns makes the codebase more maintainable, scalable, and

testable. Clean Architecture promotes the idea that the core business logic should be isolated

from the external layers, allowing for more flexibility and ease of testing.

In mobile development, there are various architectural patterns such as MVC , MVVM , and

Clean Architecture , each providing a distinct way to structure the app to separate concerns and

improve maintainability. Let’s break them down: Model-View-Controller (MVC)

Structure:

  • Model : Represents the data layer and business logic. It could be a database, web service, or

in-memory data.

  • View : Responsible for rendering the UI elements and handling user interactions.
  • Controller : Acts as an intermediary between the Model and the View, updating the View

when data in the Model changes.

Pros:

  • Simple and easy to understand.
  • Suitable for small applications or simple UIs.

Cons:

  • Views in MVVM can still become complex if not managed properly.

Use Case:

MVVM is widely used in mobile development today. In Android, it pairs well with LiveData ,

ViewModel , and Data Binding. In iOS, SwiftUI heavily leverages MVVM.

Clean Architecture

Structure:

Clean Architecture divides the software system into distinct layers, typically as follows:

  • Entities (Core) : Represent the business logic and domain model of the application.

These are independent of any external dependencies like databases or UI frameworks.

  • Use Cases (Interactors) : Contain the specific application logic. They are responsible for

orchestrating the flow of data between the entities and the outer layers.

  • Interface Adapters (Presenters) : Transform the data into a format suitable for the View.

This is where the ViewModel (in MVVM) or Presenter (in MVP) would sit.

  • Frameworks and Drivers (UI, Database, Network) : These are the outermost layers that

interact with the app’s external dependencies (UI components, databases, or APIs).

Pros:

  • Separation of Concerns : Each layer has a distinct responsibility, which makes the code

more modular and easier to test.

  • Testability : Since the core business logic is isolated, it is highly testable.
  • Scalability and Flexibility : Since the system is decoupled, it is easier to scale, and

different parts of the system can be swapped out with minimal changes to other parts.

Cons:

  • Complexity : Implementing Clean Architecture can be difficult, especially for smaller apps.

It requires careful planning and discipline.

  • Overhead : The separation of layers introduces overhead, which might not be necessary for

smaller, less complex applications.

Use Case:

Clean Architecture is best suited for large-scale apps or apps that need to scale over time. It is

particularly beneficial when long-term maintainability and extensibility are priorities.

Managing Activity and Fragment Lifecycle in Android

In Android development, managing the lifecycle of Activities and Fragments is crucial to avoid

memory leaks, crashes, and to ensure the app runs smoothly. Understanding how the app

transitions between different lifecycle states is key to implementing MVVM and Clean

Architecture effectively.

Activity Lifecycle:

  • onCreate(): Called when the activity is first created.
  • onStart(): Called when the activity becomes visible to the user.
  • onResume(): Called when the activity starts interacting with the user.
  • onPause(): Called when the activity is partially visible and may be paused.
  • onStop(): Called when the activity is no longer visible to the user.
  • onDestroy(): Called when the activity is destroyed.

Fragment Lifecycle:

Here is the UML Diagram representing the MVVM Architecture for an e-commerce app:

plaintext Copy code +---------------------+ +---------------------+ +------------- - -------+ | Product |<------>| ProductModel |<------->| ProductRepository | | (Data Model) | | (Business Logic) | | (Data Source Layer)| +---------------------+ +---------------------+ +------------- - -------+ +-----------------------------------------+ | ViewModel | | (Handles UI Logic and Data Binding) | +-----------------------------------------+ ^ ^ | | +---+---+ +---+---+ | Cart | | Order | | Model | | Model | +-------+ +-------+ +--------------------+ | View | | (Activity/Fragment)| +--------------------+

3.Discuss on learning SQL on SQLite. Focus on: Using SQLite and Room database

in Android and core Data framework for iOS. Then create a mobile app to store and

retrieve use profile using SQLite.

Learning SQL on SQLite: A Discussion

SQLite is a popular lightweight database engine that is widely used in mobile development. It is

an embedded relational database, which means it is integrated directly into the application

without requiring a separate server or complex setup. SQL (Structured Query Language) is the

standard language used for interacting with relational databases, including SQLite. SQLite allows

you to create, read, update, and delete (CRUD) data using SQL commands, and it supports full

ACID (Atomicity, Consistency, Isolation, Durability) compliance.

Using SQLite in Android (with Room Database)

Android uses SQLite as the default relational database for local storage. However, direct

interaction with SQLite in Android can be cumbersome and prone to errors. Therefore, Google

introduced Room , an abstraction layer over SQLite, to simplify database management.

Room Database in Android

Room is part of Android's Architecture Components and provides a more powerful, flexible, and

type-safe way of interacting with SQLite databases. It eliminates much of the boilerplate code

associated with SQLite, offering a clear API and enhancing the development experience.

Steps to Use Room in Android:

1. Add dependencies : Add Room dependencies to the build.gradle file.

2. Define Entities : Create Java classes representing database tables.

3. Perform CRUD Operations : Use the NSManagedObjectContext to insert, fetch, update,

and delete objects.

Creating a Mobile App to Store and Retrieve User Profile

Using SQLite

Gradle

dependencies { implementation 'androidx.room:room-runtime:2.5.0' annotationProcessor
'androidx.room:room-compiler:2.5.0' }
Define the UserProfile entity, DAO, and AppDatabase.
Java public class MainActivity extends AppCompatActivity {
private AppDatabase db;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); db =
Room.databaseBuilder(getApplicationContext(), AppDatabase.class, "user_database").build(); // Insert
User Profile
UserProfile profile = new UserProfile(); profile.setName("John
Doe"); profile.setEmail("[email protected]"); new Thread(()
  • > { db.userProfileDao().insert(profile); }).start();
  • Resources : The data or objects exposed by the API (e.g., users, weather data, etc.).
  • Endpoints : URLs used to interact with the resources. Each endpoint corresponds to a

specific resource (e.g., GET /weather to get weather data).

  • HTTP Methods : These represent actions performed on the resources:

o GET: Retrieve data from the server. o POST: Send data to the

server to create or update resources. o

PUT/PATCH: Update a resource. o DELETE: Remove a resource.

In mobile app development, JSON is commonly used for data interchange due to its simplicity and

flexibility. Mobile apps make HTTP requests to RESTful APIs, parse the JSON responses, and

display the data to the user.

code @SerializedName("main") private Main main; public class Main { @SerializedName("temp") private double temperature; } public double getTemperature() { return main.temperature; } }

Step 3: Create Retrofit Interface

java Copy code public interface WeatherService { @GET("data/2.5/weather") Call getWeather(@Query("q") String city, @Query("appid") String apiKey);

Step 4: Set Up Retrofit and Make Request

java Copy code Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://api.openweathermap.org/") .addConverterFactory(GsonConverterFactory.create()) .build(); WeatherService service = retrofit.create(WeatherService.class); Call call = service.getWeather("London", "your_api_key"); call.enqueue(new Callback() { @Override public void onResponse(Call call, Response response) { if (response.isSuccessful()) { double temperature = response.body().getTemperature();

// Update UI with the temperature
@Override public void onFailure(Call call,
Throwable t) { // Handle failure