Lecture 8 - Android Lab

Lecture Date: Friday, September 14

Follow the tutorial found here: https://google-developer-training.github.io/android-developer-fundamentals-course-practicals/en/Unit%201/23_p_activities_and_implicit_intents.html

Addition to the "first app" you build in this tutorial: add code so that whichever button you press ALSO pops up with that information in a toast at the bottom of the screen.

Submit a zip file of each Android project you craeted to the appropriate assignment found in Collab.

If you wish to work on the lab before coming to class, that is fine.

No Audio Today

more ...

Lecture 7 - Android Lifecycle

Lecture Date: Wednesday, September 12

We will finish up from last lecture along with covering more on the Android lifecycle, including how to handle device rotation.

Device Rotation - https://github.com/marksherriff/RotationExample

Then, how do you get info BACK from an activity? https://developer.android.com/training/basics/intents/result

We'll top everything off by looking at how application signing works in Android.

Finally, if there's time, we'll take a look at Kotlin: https://kotlinlang.org/docs/reference/

Other resources on fragments for the curious:

more ...

Lecture 6 - Android Intents and Services

Lecture Date: Monday, September 10

Today, we'll discuss Intents and Services. One is used for passing messages and one is basically an Activity with no UI. Guess which is which.

For information on how to handle user permissions, see https://developer.android.com/training/permissions/requesting.

IntentExamples on Github: https://github.com/marksherriff/IntentExamples

ServiceExample on Github: https://github.com/marksherriff/ServiceExample

Slides - Android Intents and Services

more ...

Lecture 5 - Android Activities

Lecture Date: Friday, September 7

We will start by looking at Github and how to use it for your project.

The main part of any Android App is the Activity. Today we'll discuss how Activities work, how they are put together, their lifecycle, and how to manage them as a part of the larger Android system.

Slides - Android Activity

ListExample on GitHub - https://github.com/marksherriff/ListExample

RecyclerView tutorials at:

more ...

Lecture 4 - Android Studio

Lecture Date: Wedneday, September 5

We'll start here with finishing up the Android lifecycle before looking at the IDE we'll be using: Android Studio

We will make sure to touch on:

  • Creating a new project
  • Parts of the project
  • Basics of UI
  • Android Device Monitor
  • Connecting to GitHub
  • SDK Manager
  • Virtual Device Management
  • HAXM
  • Gradle
  • Project Listing vs. File Listing

We'll put together a very simple application to see how to get going. We'll also talk a bit about signing your apps (hopefully).

  • Doing onClick in XML
  • Connecting UI parts to code

In going through this app, we'll start talking about what makes up an Android app.

CWIT Meetup Name Generator on GitHub: https://github.com/marksherriff/CWITMeetupNameGenerator

more ...

Lecture 2 - How is it different?

Lecture Date: Friday, August 31

Today we begin our trek into mobile development.

"Hey, we've been writing programs since CS1110!" you might say. "How different can this be?"

Quite a few ways.

Some of you (?) built an Android app in CS 2110. The main purposes there were to 1) get students excited about computing ("I wrote something and wow it's running on this other thing! Neat!") and 2) to get you using a framework you have to learn (and there's plenty of that in Android). We'll focus some time in this class on both these things, but first we need to talk about how software development for a mobile device is different than for a desktop (or for a browser).

So far, you've seen a few different software delivery paradigms:

  • desktop model - stand-alone application on a single-user machine; this could be a console window or a GUI app
  • client-server / web model - an application broken into several pieces across multiple machines and is accessible to many users; GUI written in a markup language of some kind

Now we're adding the mobile model.

Some things to consider:

  • Screen real estate - You no longer have a huge screen to show lots of information on. You have to make careful choices as to what should be displayed.
  • Interface - You no longer have a mouse and keyboard. You have your fat, imprecise, greasy finger.
  • Platform differences - Writing for different browsers is one thing. Writing for different mobile platforms is a whole other one.
  • Platform guidelines - Along the same lines, we now have more rules to follow.
  • App distribution - This is a completely different model than what we're used to with the other models. The "walled garden" is in full effect here, mainly coming from the history of mobile.
  • How people consume the app - For the other types, people are (usually) sitting still. Definitely not so with mobile!
  • Sensors - Your desktop might have a mic and camera, but does it have an accelerometer, gyroscope, and GPS?

We have to rethink building software again with mobile.

Lessons from the InfoWorld article:

  • Every Pixel Counts
  • Focus on user experience
  • Deal up front with memory and bandwidth constraints
  • Choose carefully between native and Web development
  • Think about how to take advantage of location
  • Rely on server-side data synchronization
  • Design and code for touch interfaces
  • Don't get too dependent on hardware performance
  • Expect users to make mistakes

Model-View-Controller is the general paradigm / architecture we'll be dealing with all semester. Best learn it now!

Slides - Mobile Device Architecture

more ...

Lecture 1 - Welcome and Intro

Lecture Date: Wednesday, August 29

Welcome back to UVA! We'll do the syllabus dance today, talk about the projects, and how horrible the wait list is. See the syllabus for more info on how I'll be letting people into the course.

more ...