Lecture 11 - iOS Lab

Lecture Date: Friday, February 9

Lab assignment today!

The lab can be found here: https://github.com/marksherriff/iOS-lab-stopwatch

You are allowed to work with someone this week on the lab, either on a Mac laptop or on the Macs in the lab.

If you own a Mac laptop -or- you are going to work with someone with a Mac laptop: Please go to our normal classroom for the lab

If you do not own a Mac laptop: Please go to Rice 340 for the lab

No Audio Today

more ...

Lecture 10 - Intro to Xcode

Lecture Date: Wednesday, February 7

Today we are going to build a simple app together, looking at how to navigate the ins and outs of Xcode.

Here are some major points we will look at:

  • Adding a developer account
  • Using the Interface Builder
  • Adding more screens
  • Using a Navigation Controller
  • Segues

Some good tutorials to look at:

Slides - iOS App Architecture

LectureTest on Github: https://github.com/marksherriff/LectureTest-iOS.git

Note Taker on Github: https://github.com/marksherriff/NoteTaker-iOS.git

more ...



Lecture 7 - Android Lifecycle

Lecture Date: Wednesday, January 31

We will finish up from last lecture along with covering more on the Android lifecycle, including:

Slides - Android Activity

Tutorial on Fragments: http://www.vogella.com/tutorials/AndroidFragments/article.html

Android's Tutorial on Fragments: https://developer.android.com/training/basics/fragments/creating.html

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

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

Also how to share the Android signing key!

more ...


Lecture 5 - Android Activities

Lecture Date: Friday, January 26

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, January 24

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, January 19

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 ...