Mobile Application Development II – SS2 Digital Technologies Lesson Note (Third Term)
Lesson note at a glance
- Class
- SS2
- Subject
- Digital Technologies
- Term
- Third Term
- Reading time
- 6 min
Mobile application development is the process of designing, coding, testing and fixing apps that run on phones and tablets.
Behavioural objectives
By the end of the lesson, students should be able to:
- State what an IDE is and name the IDEs used for Android, iOS and hybrid apps.
- Describe what an emulator does.
- Identify common views and layouts used to design a user interface.
- Name the programming languages used for Android and iOS apps and explain what a click listener does.
- List the steps for creating a simple app.
- Explain the terms bug, debugging and testing.
What is an IDE?
An IDE (Integrated Development Environment) is a software tool where a developer writes code, designs screens and tests an app.
- Simple picture: an IDE is a digital workshop, just as a builder needs tools to build a house.
- Code editor: the place where the developer types the code.
- Design view: the place where the developer arranges buttons, text and images.
- Emulator: a virtual phone for running the app on the computer.
Which IDEs are used to build mobile apps?
| Tool | Used for | Note |
|---|---|---|
| Android Studio | Android apps | The official tool for Android. |
| Xcode | iPhone (iOS) apps | The official tool for iOS. It runs on Apple Mac computers. |
| VS Code | Hybrid apps | A popular code editor used with hybrid tools such as Flutter and React Native. |
What is an emulator?
An emulator is a virtual phone that appears on the computer screen and runs the app like a real phone.
- Saves cost: the developer does not need to buy a real phone for every test.
- Saves time: the app can be run and checked quickly during building.
- Different devices: the developer can choose different screen sizes to test on.
- Xcode: its virtual phone is usually called a simulator.
What is the difference between native and hybrid apps?
A native app is built for one platform only, using that platform’s own tools and language.
A hybrid app is built once with one set of code and runs on both Android and iOS.
| Point | Native app | Hybrid app |
|---|---|---|
| Platforms | One (Android or iOS) | Both Android and iOS |
| Code | Separate code for each platform | One shared code base |
| Example tools | Android Studio, Xcode | Flutter, React Native |
How do you design the user interface (UI)?
The UI (User Interface) is everything the user sees and touches on the screen of an app.
- First step: design the UI before writing the logic.
- Building blocks: the UI is built from views placed inside layouts.
- Design language: on Android, the screen design is written in XML.
What are views?
A view is a single item shown on the screen, such as text, a picture or a button.
Think of the phone screen as a blank wall. You pin different items on it:
- TextView: displays text, such as a headline or a label.
- ImageView: shows pictures.
- Button: something the user taps to make something happen.
- EditText: a box where the user types a name, a password or a number.
What are layouts?
A layout is an invisible container that holds views and fixes their positions on the screen.
- LinearLayout: places items one after the other, in a column (top to bottom) or in a row.
- ConstraintLayout: anchors each item to the edges of the screen or to other items.
How do you make the app work?
Code makes an app respond when the user touches the screen.
- Without code: a button that does nothing when tapped makes the app “dead”.
- Android: developers usually use Kotlin or Java.
- iOS: developers use Swift.
- Hybrid: the language depends on the tool, for example Dart for Flutter and JavaScript for React Native.
What is a click listener?
A click listener is a small piece of code that waits for the user to tap a button and then runs an action.
- It listens: it waits for a tap on a chosen button.
- It reacts: it opens a new page, shows a “Success” message or calculates an answer.
- Link to the UI: the code finds the button through its ID, such as btnSubmit.
What are the steps for creating a simple app?
A simple “Greet” app asks for a name, waits for a button click and then says “Hello!”.
- Start a new project: open the IDE and choose an “Empty Activity” template.
- Draw the UI: drag a “Plain Text” box (for the name) and a Button onto the screen.
- Give them IDs: every item needs a name so the code can find it, for example btnSubmit.
- Write the logic: tell the app, “When btnSubmit is clicked, take the text from the box and show it in a pop-up message.”
- Run the app: start the emulator and see how the app looks and behaves.
- Test and fix: try different names, find any bugs and correct them.
What are the main components of an app?
The main components of an Android app are the activity, the XML design file, the logic code and the manifest.
| Component | What it is | Why we use it |
|---|---|---|
| Activity | A single screen. | To organise the different parts of the app. |
| XML | The design language. | To tell the phone where to put the buttons. |
| Kotlin/Swift | The logic language. | To tell the phone what to do when buttons are clicked. |
| Manifest | The “ID Card” of the app. | To tell the phone the app’s name and permissions (like camera access). |
What are bugs, debugging and testing?
A bug is a mistake in the code that makes an app behave wrongly or crash.
Debugging is the process of finding and fixing bugs.
Testing is the process of running an app to check that it works as expected.
What are the common kinds of bugs?
- Syntax error: the code breaks the rules of the language, such as a missing bracket.
- Logic error: the app runs but gives a wrong answer, such as adding when it should subtract.
- Runtime error: the app crashes while it is running.
How do you debug an app?
- Run the app and notice what goes wrong.
- Read the error message shown in the IDE.
- Find the line of code that causes the problem.
- Correct the code.
- Run the app again to confirm the bug is gone.
How should you test an app?
- Different screen sizes: an app that looks good on a tablet may look poor on a small phone.
- Different inputs: try empty boxes, long names and wrong entries.
- Every button: tap each button to confirm it does its job.
Teacher’s tip: Do not be discouraged if your app crashes the first time. Read the error message and fix one bug at a time.
Evaluation
- What is an IDE? Name the official IDE for Android apps and the one for iOS apps.
- What is the use of an emulator?
- State the job of each of these views: TextView, ImageView, Button and EditText.
- Which languages are used for Android apps and which for iOS apps?
- What is a bug, and what is debugging?
Assignment
- Sketching: On a sheet of paper, draw three screens for a “School Library” app: Login, Book List and Book Details. Label the views (TextView, ImageView, Button, EditText) and the layout you would use on each screen.
This term's Digital Technologies topics
SS2 Third Term · 8 topics

