Handles downloading the specifications for the homescreen and applying them to the layout, including the contained banners and buttons. ModularHomeScreenFragment The container for all of the homescreen content. Uses custom RecyclerView.Adapter (ModularHomeScreenAdapter) to display elements, which have their own custom Views based on purpose (banner, image, Instagram etc – see views folder). NNBannerFragment Fragment that […]
Various common UI elements. NNStartupActivity Abstract class to be implemented in app startup Activity. Defines tasks to be run before showing the first screen e.g. downloading settings, version check. imaging folder Various classes for handling images: NNCircleImageView – Generate circular ImageView. Extends NNImageView NNImageCarousel – Create image carousel from a list of image urls NNImageView […]
Framework to acquire and implement settings from CMS. NNSettings/SettingsManager/SettingsORM etc. Acquires settings from the settings database, which is stored locally after being periodically downloaded from CMS. Used very frequently. EnvironmentsActivity/EnvironmentManager/Environments Sets the environment – QA, production etc. UnpackAssets Acquires a JSON list of assets and saves them in the device storage, if run mode is […]
These are the frameworks that NN4M uses to establish core functionality and consistency across their apps. nnbase This is the root framework and is a dependency of several of the others. It is essential for every app. nnnetwork Dependencies: nnbase Framework for making network requests: AbstractRequest – non-specific request type, forms basis for other request […]
This is the root framework and is a dependency of several of the others. It is essential for every app. NNApplication This file, or a subclass of it, should be declared in the AndroidManifest.xml as: <applicationandroid:name=”.NNApplication”… >…</application> This means that the entire app will be based on the NNApplication class. This provides core functionality such […]
Coroutines are Kotlin’s way of dealing with asynchronous tasks. They can execute tasks sequentially. Coroutines require a: Job – cancellable background task with a lifecycle that culminates in its completion. Jobs can be arranged in a parent-child hierarchy so that cancellation of the parent cancels all child jobs Dispatcher – sends off coroutines to run […]
Use
Trigger the vibrate function on the device
In AndroidManifest.xml: <manifest xmlns:android=”http://schemas.android.com/apk/res/android” xmlns:tools=”http://schemas.android.com/tools” package=”com.example.android.myapp”> <application android:allowBackup=”true” tools:ignore=”GoogleAppIndexingWarning”> <!– Screen locked to landscape for easier play –> <!– configChanges attribute makes the following actions NOT cause a config change –> <!– screenOrientation attribute sets the default animation–> <activity android:name=”.MainActivity” android:configChanges=”keyboardHidden|orientation|screenSize” android:screenOrientation=”landscape”> <intent-filter> <action android:name=”android.intent.action.MAIN” /> <category android:name=”android.intent.category.LAUNCHER” /> </intent-filter> </activity> </application> </manifest>
When you need to do more than pass a simple variable value along to a layout xml via data bainding
We can use data binding along with Lifecycle components (e.g. ViewModel and LiveData) to remove the controller (Activity or Fragment) as middle-man from the process of passing data from the ViewModel to the View. Without data binding (at least, only using data binding to avoid findViewById): import … class MyFragment : Fragment() { private lateinit […]
Create internal and external version of the variables that need to be passed out of our class, so that other classes cannot modify the internal data. import … class MyViewModel : ViewModel() { // The variable to be passed out of the class private val _variable = MutableLiveData<String>() // Private internal class, mutable val variable: […]
How to kill a process on your test device or emulator using adb
Add Jake Wharton’s Timber logging library to your app
We can create our own animations and apply them (or premade animations) using the Navigation component
Add a Listener which will affect the behaviour of the Nav Drawer using the Navigation component
Adding a Navigation drawer using the Navigation component in Kotlin
Using safe-args plugin to make sure the data you pass between Activities/Fragments is reliable
Add overflow menu with Navigation component in Kotlin
Adding Up Navigation support to the Android Navigation component
Adding the Navigation component to an Android project in Kotlin
The code to add to a Fragment to generate data binding in Kotlin
Data binding in Kotlin
Taking lambda as an argument in a function
Using the lateinit modifier to delay initialisation without null checks
Things to consider when calling Java from Kotlin
Things to consider when calling Java from Kotlin
How to deal with differences in nullability between Java and Kotlin
Navigating and printing the file tree
File IO in Kotlin
Use of covariance and contravariance within functions in Kotlin
Understanding how contravariance affects the ability to use Generics in Kotlin
Understanding how covariance affects the ability to use Generics in Kotlin
Reify parameters to allow us to use Generics at runtime
Using functions with Generics in Kotlin
Using generics
Using Sequences – the equivalent to Java Streams
Useful functions for Kotlin Collections
Using Sets in Kotlin
Using Maps in Kotlin
Using Lists in Kotlin
Lambdas with receivers in Kotlin
Using lambdas in Kotlin
Lambdas in Java
Loops in Kotlin
Using the Try/Catch statement in Kotlin
Imports in Kotlin
Enums in Kotlin
Use of the object keyword in Kotlin
Interfaces in Kotlin
Inheritance in Kotlin
Inline functions in Kotlin
Add functions to existing classes
Using functions in Kotlin
Kotlin Data class
Kotlin Access Modifiers & Constructors
Kotlin’s handling of arrays
Datatype rules for Kotlin
Declaration rules for Kotlin
Kotlin vs Java Access Modifiers for Top-Level Items Screenshot
Commands for git:
Customise the appearance of the action bar at the top of your app
Customise the appearance of the action bar at the top of your app
Gives visual feedback when an item is pressed
To cater for the wide variety of device specifications, we need to consider screen size and density
Customise the appearance of multiple objects at once with consistent visuals
If wanting to set differing layouts for a RecyclerView in a particular ViewHolder position +/- orientation (portrait or landscape)
If creating multiple instances of the same layout it is good practice to save that layout code in its own file and instantiate it using the
To efficiently utilise the space available in a landscape orientation, Android allows the defining of an alternative layout
The adaptation of a product or service to meet the needs of a particular language, culture or desired population’s “look-and-feel”
Make your app accessible to those with visual or hearing impairments
How to bind data from your app code to the UI, without using findViewById every time
How to set up a Job Schedule. Consider FirebaseJobDispatcher instead for greater backwards compatibility
How to set up a Job Schedule. Consider FirebaseJobDispatcher instead for greater backwards compatibility
Explanation of Foreground Services
How to set up a Job Schedule. Consider FirebaseJobDispatcher instead for greater backwards compatibility
How to set up a Job Schedule. Consider FirebaseJobDispatcher instead for greater backwards compatibility
Explanation of Foreground Services
How to add action buttons to your Notification
How to create the ever-essential Notification
This configures the permissions for services, private activities and broadcast-protected Intents to be started via Intent from e.g. a notification or another app
Provides correct grammatical syntax when creating Strings that describe a varying number of items
A Service which runs off a completely separate thread to the main
Services are Android Framework components meant for running background tasks that don’t need a visual component, therefore they do not provide a User Interface (UI)
Description of the Android Lifecycle
ViewModelFactory allows us to produce custom ViewModels that allow for the inclusion of arguments in the Constructor (standard ViewModels do not)
ViewModel preserves data beyond the lifecycle of individual Activities i.e. it is lifecycle-aware – it will hold data for the UI even if e.g. the screen is rotated, causing the Activity to be remade
LiveData is an observable data holder class. This means it sits between the database and UI, and monitors changes in the database
Defines the methods by which Room can convert data types in order to write to and read from a database
An interface (API) which allows us to interact with our SQLite database tables
Defines our SQLite database tables
To add the desired elements of Android Jetpack to your app
A cheatsheet for SQLite commands
Room is one of the Android App Architecture Components. The Room persistence library (Object Relational Mapping library) provides an abstraction layer over SQLite to allow for more robust database access while harnessing the full power of SQLite
The 4 main components of an Android app
A floating action button (FAB) performs the primary, or most common, action on a screen. It appears in front of all screen content, typically as a circular shape with an icon in its center.
Add an ItemTouchHelper to recognize when a user swipes to e.g. delete an item. An ItemTouchHelper enables touch behaviour (like swipe and move) on each ViewHolder, and uses callbacks to signal when a user is performing these actions.
CursorLoader (like all Loaders) is deprecated. Do not use.
SQLite databases are commonly used for on-device storage of data. Databases can be created and manipulated using the standard SQL commands
This interface provides random read-write access to the result set returned by a database query.
How to use a ContentResolver to acquire data from an external data source e.g. another app’s data or the Calendar or Contacts data on the phone.
Implement a PreferenceChangeListener (in a Settings Fragment) to do something when the user attempts to change a Preference setting, but before it is written to the Shared Preferences
Typical xml code for an edit text preference entry
ListPreference items in Preference screens do not automatically provide a label showing their current value. You can create labels for all list Preference items as so
Typical xml code for list preference entry
Typical xml code for checkbox preference entry
How to make user changes to options within the Settings Fragment affect changes in the app
How to set up a settings Activity with a PreferenceFragment
How to persist data across changes in state such as device rotation
Table summarising the options for persistent data storage
This function is deprecated. Do not use.
List of stages for the Android Activity lifecycle
Infographic of typical Views within Android
Infographic summarising the various Collection options for array storage of data e.g. sets, maps, lists
Using ArrayLists
Open a third party app to view a webpage using implicit Intent.
Add a ClickListener to an item
Add a ClickListener to an item.
Configure a RecyclerView. Should be used instead of a ListView.
Add a toast message
Basic example of parsing data from a JSON.
How to set up an AsyncTask to take a task off the main thread
How to request a permission for your app
URL is a specific class of Uri. Use the following function to compile a valid URL.
Create a menu in the ActionBar. Can be in the main bar or under the menu icon.
LinearLayout with an EditText, a TextView and a ScrollView with TextView.
Example of Scrollview within FrameLayout xml
How to add an Activity to your app and navigate to it using an explicit Intent.
