Mobile Application Development

The Android emulator (Android Virtual Device) imitates a real Android device on the development computer. Its task is to let developers run, test and debug applications on different screen sizes, API levels and hardware configurations without a physical device.

View hierarchy is the tree structure of UI elements in an Android screen. The root is a ViewGroup (such as a layout) that contains child Views and other ViewGroups, and the system draws and handles events by traversing this tree from the root downward.

An Activity is an Android application component that provides a single screen with a user interface where users interact with the app, for example a login screen. It is a subclass of Activity (or AppCompatActivity) and is declared in AndroidManifest.xml.

An Adapter acts as a bridge between a data source (array, list, database cursor) and an AdapterView such as ListView, GridView, Spinner or RecyclerView. It converts each data item into a View and supplies it to the UI, so large data sets can be displayed efficiently, with views reused.

SharedPreferences is an Android mechanism for storing small amounts of private data as key-value pairs (e.g. settings, login state) in an XML file. The data persists across application sessions.

A thread is the smallest unit of execution within a process. In Android, the main (UI) thread handles the user interface, and background (worker) threads perform long tasks such as network or database operations so that the UI does not freeze.

LinearLayout is a ViewGroup that arranges its child views in a single direction, either horizontally or vertically, as set by android:orientation. The layout_weight attribute can be used to share space among the children.

An intent filter is a declaration in AndroidManifest.xml that specifies which implicit intents a component (activity, service or broadcast receiver) can respond to. It uses the <action>, <category> and <data> elements to match incoming intents.

A ContentProvider manages access to a structured set of data and shares it between applications in a controlled way. It offers a standard interface (URI with query, insert, update, delete) and enforces permissions, e.g. the Contacts provider.

Two aspects of Android debugging are:

• Viewing log messages with Logcat (using Log.d(), Log.e() etc.).
• Setting breakpoints and stepping through the code in the Android Studio debugger while inspecting variables.

LinearLayout arranges its children in a single row (horizontal) or a single column (vertical), set by android:orientation. Children are placed one after another, and android:layout_weight distributes the remaining space proportionally. It is simple and good for forms and lists of components.

<LinearLayout android:orientation="vertical"
    android:layout_width="match_parent" android:layout_height="match_parent">
    <TextView android:text="Name" ... />
    <EditText ... />
</LinearLayout>

FrameLayout is the simplest layout and is designed to hold a single child. Children are stacked on top of each other at the top-left corner, with the last added drawn on top, and their position can be adjusted with android:layout_gravity. It is used for overlays, such as text on an image, and as a container for fragments.

Difference: LinearLayout puts children side by side or one below another, whereas FrameLayout overlaps them in a stack.

An activity passes through the following callback methods during its life cycle:

• onCreate(): called when the activity is first created. Initialise the UI (setContentView) and variables.
• onStart(): the activity becomes visible.
• onResume(): the activity is in the foreground and the user can interact with it (running state).
• onPause(): another activity is coming to the foreground; save unsaved data and stop heavy tasks.
• onStop(): the activity is no longer visible.
• onRestart(): called when a stopped activity is started again, followed by onStart().
• onDestroy(): called before the activity is destroyed, to release resources.

Flow: onCreate → onStart → onResume → (running) → onPause → onStop → onDestroy. From onPause the activity may return to onResume, and from onStop it may go through onRestart.

A GridView shows items in a two-dimensional scrollable grid. It is implemented in three steps: add it to the layout, prepare the data, and attach an adapter.

activity_main.xml

<GridView
    android:id="@+id/gridView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:numColumns="3"
    android:horizontalSpacing="8dp"
    android:verticalSpacing="8dp" />

MainActivity.java

GridView gridView = findViewById(R.id.gridView);
String[] items = {"One", "Two", "Three", "Four", "Five", "Six"};
ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
        android.R.layout.simple_list_item_1, items);
gridView.setAdapter(adapter);
gridView.setOnItemClickListener((parent, view, position, id) ->
        Toast.makeText(this, items[position], Toast.LENGTH_SHORT).show());

For images or custom cells, a custom adapter extending BaseAdapter with its own getView() is used.

Key-value pairs are stored with SharedPreferences. Data is written through a SharedPreferences.Editor and read with getter methods that take a default value.

// Store
SharedPreferences sp = getSharedPreferences("MyPrefs", MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.putString("username", "Ram");
editor.putInt("age", 21);
editor.putBoolean("loggedIn", true);
editor.apply();   // or commit()

// Retrieve
SharedPreferences sp2 = getSharedPreferences("MyPrefs", MODE_PRIVATE);
String name = sp2.getString("username", "default");
int age = sp2.getInt("age", 0);
boolean in = sp2.getBoolean("loggedIn", false);

apply() saves asynchronously, while commit() saves synchronously and returns a boolean. Values can be removed with editor.remove(key) or editor.clear().

A content provider exposes data through a content URI, and other components retrieve it using a ContentResolver. To retrieve cached files (for example files in the app's cache directory shared via a FileProvider, a subclass of ContentProvider):

1. Declare the provider in AndroidManifest.xml with an authority and a file_paths.xml that lists the cache path (<cache-path name="cache" path="." />).
2. Build the URI for the file:

File file = new File(getCacheDir(), "image.png");
Uri uri = FileProvider.getUriForFile(this, "com.example.app.fileprovider", file);

3. Query/open through the resolver:

ContentResolver resolver = getContentResolver();
InputStream in = resolver.openInputStream(uri);   // read the file content
Cursor c = resolver.query(uri, null, null, null, null); // name, size

4. Read the data from the stream or cursor and close it. Read permission can be given to another app with intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION).

The provider thus controls access while the client only needs the URI.

The SmsManager class is used to send SMS from an app (requires the SEND_SMS permission). Common methods are:

• getDefault() / getSystemService(SmsManager.class): gets an instance of SmsManager.
• sendTextMessage(destAddress, scAddress, text, sentIntent, deliveryIntent): sends a text message to a phone number.
• divideMessage(text): splits a long message into parts that fit the SMS size limit (160 characters).
• sendMultipartTextMessage(...): sends a message divided into several parts.
• sendDataMessage(...): sends a data (binary) message to a port.
• getSubscriptionId() / getSmsManagerForSubscriptionId(id): selects the SIM in dual-SIM phones.

Creating an application

1. Install Android Studio and the SDK.
2. Create a new project (File > New > New Project), choose a template (e.g. Empty Activity), the language (Java/Kotlin), package name and minimum SDK.
3. Design the UI in XML (res/layout) and write the logic in the activity class.
4. Declare components and permissions in AndroidManifest.xml, and keep resources (strings, images) in res/.
5. Build with Gradle, which generates the APK.

Testing

• Run the app on an emulator (AVD) or a real device connected via USB with debugging enabled.
• Unit tests (JUnit, in src/test) check logic on the JVM.
• Instrumented/UI tests (Espresso, in src/androidTest) run on a device and test user interactions.
• Test on different screen sizes, API levels and orientations.

Debugging

• Logcat shows system and app logs, using Log.d(TAG, "message"), Log.e(), filtered by tag and level.
• Breakpoints: run in debug mode, pause at a line, step over/into, and inspect or watch variables in the debugger.
• Layout Inspector and Profiler help find UI, CPU, memory and network problems.
• Read the stack trace of exceptions to find the failing line, then fix and rerun.

The cycle of write, run, test and debug is repeated until the app works correctly.

An Android widget (App Widget) is a small view of an application that is shown on the home screen, so users can see information or do quick actions without opening the app, e.g. clock, weather or music controls. It is implemented with an AppWidgetProvider (a BroadcastReceiver), an XML layout using RemoteViews, and an appwidget-provider metadata file, and is declared in the manifest.

Key features

• Appears on the home screen and can be resized and placed by the user.
• Updates periodically (updatePeriodMillis) or when triggered by events.
• Uses RemoteViews with a limited set of layouts and views (such as TextView, ImageView, Button, ListView).
• Can handle clicks with PendingIntent to launch the app or perform an action.
• Types include information, collection, control and hybrid widgets.
• Has lifecycle callbacks: onUpdate(), onEnabled(), onDisabled(), onDeleted().

Benefits

• Gives quick, at-a-glance information and one-tap access to features.
• Improves user engagement and app visibility.
• Saves time because the app need not be opened.
• Customisable home screen for the user.
• Keeps the app's content fresh without the user opening it.

RecyclerView is an Android widget that displays a large data set efficiently by recycling item views that scroll off screen instead of creating new ones.

Steps to implement it

(1) Add the dependency and the widget. Add androidx.recyclerview:recyclerview in build.gradle, then place it in the layout:

<androidx.recyclerview.widget.RecyclerView
    android:id="@+id/recyclerView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

(2) Create the item layout (item_student.xml) describing one row, e.g. a TextView for the name.

(3) Create the data model, e.g. class Student(val name: String).

(4) Create the ViewHolder and Adapter. The adapter extends RecyclerView.Adapter and overrides three methods:

• onCreateViewHolder() inflates the item layout and returns a ViewHolder.
• onBindViewHolder() binds data at a position to the views.
• getItemCount() returns the number of items.

class StudentAdapter(private val list: List<Student>) :
    RecyclerView.Adapter<StudentAdapter.VH>() {
    class VH(v: View) : RecyclerView.ViewHolder(v) {
        val name: TextView = v.findViewById(R.id.tvName)
    }
    override fun onCreateViewHolder(p: ViewGroup, t: Int) =
        VH(LayoutInflater.from(p.context).inflate(R.layout.item_student, p, false))
    override fun onBindViewHolder(h: VH, pos: Int) { h.name.text = list[pos].name }
    override fun getItemCount() = list.size
}

(5) Set the LayoutManager and Adapter in the Activity.

val rv = findViewById<RecyclerView>(R.id.recyclerView)
rv.layoutManager = LinearLayoutManager(this)   // or GridLayoutManager
rv.adapter = StudentAdapter(listOf(Student("Ram"), Student("Sita")))

(6) Handle clicks and updates by setting click listeners in the ViewHolder and calling notifyDataSetChanged() or notifyItemInserted() when data changes.

SQLite is a lightweight, open-source, serverless, self-contained relational database engine embedded in Android. It needs no configuration and stores the whole database in a single file on the device, and it is queried with standard SQL.

How data is stored

• The database is a single file kept in the app's private storage (/data/data/<package>/databases/), accessible only to that app.
• Data is organised in tables of rows and columns, with types such as INTEGER, TEXT, REAL, BLOB, and a primary key for each row.
• In Android, a subclass of SQLiteOpenHelper creates and upgrades the database (onCreate(), onUpgrade()).
• Data is inserted, read, updated and deleted using SQLiteDatabase methods (insert(), query(), update(), delete()) or raw SQL via execSQL() and rawQuery(). Results are read through a Cursor.

class DBHelper(c: Context) : SQLiteOpenHelper(c, "school.db", null, 1) {
    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL("CREATE TABLE student(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT)")
    }
    override fun onUpgrade(db: SQLiteDatabase, o: Int, n: Int) {
        db.execSQL("DROP TABLE IF EXISTS student"); onCreate(db)
    }
}
// insert
val cv = ContentValues().apply { put("name", "Ram") }
dbHelper.writableDatabase.insert("student", null, cv)

(a) Needs for UI flexibility (3 marks)

Android apps run on phones, tablets, foldables and TVs, with different screen sizes, densities and orientations. A flexible UI is needed to:

• adapt one app to both small and large screens (e.g. list and detail side by side on a tablet, one at a time on a phone);
• support portrait and landscape orientation without rebuilding the whole screen;
• reuse UI parts across several activities, which reduces duplicate code and eases maintenance;
• update part of the screen dynamically (add, replace, remove) without restarting the activity.

Fragments provide this modularity.

(b) Activity vs Fragment (3 marks)

(c) Passing data between fragments (4 marks)

Fragments should not talk to each other directly; data goes through the host activity or a shared ViewModel.

1. Fragment Result API (recommended):

// Sender
parentFragmentManager.setFragmentResult("key", bundleOf("name" to "Ram"))
// Receiver
parentFragmentManager.setFragmentResultListener("key", viewLifecycleOwner) { _, b ->
    val name = b.getString("name")
}

2. Shared ViewModel: both fragments obtain the same ViewModel scoped to the activity (activityViewModels()); one writes to LiveData and the other observes it.

3. Arguments Bundle (when starting a fragment): fragment.arguments = bundleOf("name" to "Ram"), read with requireArguments().

4. Interface callback through the activity: the fragment defines an interface, the activity implements it and forwards the data to the other fragment.

(a) Handler and Runnable for background work (6 marks)

Android's UI (main) thread must never be blocked by long tasks such as network or database work (it causes ANR, "Application Not Responding"), and UI views may only be touched from the main thread.

• A Runnable holds the code to run, in its run() method.
• A Handler is attached to a thread's Looper and posts Runnables or Messages to that thread's message queue.

Pattern: do the work in a background thread, then use a Handler created on the main Looper to post the UI update.

val uiHandler = Handler(Looper.getMainLooper())

Thread {
    val result = loadFromNetwork()          // long task, background thread
    uiHandler.post {                        // Runnable executed on UI thread
        textView.text = result              // safe UI update
    }
}.start()

Other useful methods: postDelayed(runnable, ms) to run after a delay, sendMessage() / handleMessage() for passing data, and removeCallbacks() to cancel. Alternatively runOnUiThread() or View.post() can be used. This keeps the UI responsive and thread-safe.

(b) Creating and publishing an app on Google Play (4 marks)

1. Develop and test the app in Android Studio; set a unique applicationId, version code and version name.
2. Build a signed release App Bundle (.aab) (Build > Generate Signed Bundle) using your own keystore; keep the key safe.
3. Create a Google Play Developer account (one-time registration fee, USD 25).
4. In Play Console, create the app: name, language, free or paid.
5. Fill the store listing: description, icon, screenshots, feature graphic, category, contact details.
6. Complete content rating, privacy policy, data safety and target audience forms.
7. Upload the .aab to a release track (internal, closed, open testing or production), add release notes.
8. Set pricing and countries, then submit for review. After approval, the app is published and updates are released with a higher version code.