Pattern-Oriented Software Architectures: Programming Mobile Services for Android Handheld Systems

The course is organized into the following sections:

• Section 0: Course Introduction
  • Part 1: Overview of Mobile Cloud Computing with Android
  • Part 2:Course Structure and Topics
  • Part 3: Course Prerequisites and Learning Strategies
  • Part 4: Overview of Patterns and Frameworks
• Section 1: Android Concurrency
  • Module 1: Concurrency Motivations and Challenges
    • Part 1: Concurrency Motivations
    • Part 2: Concurrency Challenges
  • Module 2: Java Concurrency Mechanisms
    • Part 1: Overview of Java Threads (Part 1)
    • Part 2: Overview of Java Threads (Part 2)
    • Part 3: Motivating Java Synchronization & Scheduling Mechanisms
    • Part 4: Java Synchronization and Scheduling Classes
    • Part 5: Java ReentrantLock
    • Part 6: Java ReentrantReadWriteLock
    • Part 7: Java Semaphore
    • Part 8: Java ConditionObject
    • Part 9: Java CountDownLatch
    • Part 10: Java Synchronization and Scheduling Example
    • Part 11: Java Built-in Monitor Objects
  • Module 3: Android Concurrency Frameworks
    • Part 1: Overview of Android Concurrency Frameworks and Idioms
    • Part 2: Android Looper
    • Part 3: Overview of Android Handler
    • Part 4: Posting and Processing Runnables to Android Handler
    • Part 5: Sending and Handling Messages to Android Handler
    • Part 6: The AsyncTask Framework (Part 1)
    • Part 7: The AsyncTask Framework (Part 2)
    • Part 8: Programming with Android Concurrency Frameworks (Part 1)
    • Part 9: Programming with Android Concurrency Frameworks (Part 2)
• Section 2: Android Services and Security
• Module 1: Android Services and IPC
  • Part 1: Overview of Started and Bound Services
  • Part 2: Programming Started Services (Part 1)
  • Part 3: Programming Started Services (Part 2)
  • Part 4: Android IntentService
  • Part 5: Activity and Service Communication
  • Part 6: Service to Activity Communication Using Android Messenger
  • Part 7: Programming Bound Services with Messengers (Part 1)
  • Part 8: Programming Bound Services with Messengers (Part 2)
  • Part 9: Programming Bound Services with AIDL
• Module 2: Android App Security and Risks
• Part 1: Traditional App Accounts
• Part 2: Mobile vs. Traditional App Accounts
• Part 3: App Account Mapping to Linux Users
• Part 4: Apps Lie & Steal
• Part 5: How Android Protects Apps
• Part 6: What Android Doesn't Protect
• Part 7: Avoid Storing Sensitive Data in Public Locations
• Part 8: Risks of Insecure File Permissions
• Module 3: Building More Secure Android Apps
• Part 0: The Challenge of Secure Coding
• Part 1: Security Vulnerability Walkthrough
• Part 2: Principles of Secure Abstractions
• Part 3: Avoid Coupling Data & Security State
• Part 4: Build Abstractions that are Hard to Use Insecurely
• Part 5: Bound & Strongly Type Security State
• Part 6: Avoid Conditional Logic in Secure Pathways
• Part 7: Prevent Secure Pathways from Being Broken at Runtime
• Part 8: Privilege Escalation Concepts
• Part 9: Privilege Escalation Scenario
• Part 10: Privilege Escalation Code Walkthrough
• Part 11: Privilege Escalation Fixes
• Part 12: User Interface Attacks
• Part 13: Cross-platform User Interface Attacks
• Section 3: Concurrency and Communication Patterns in Android
  • Module 1: Coordinating Concurrent Access to Shared Data
  • Part 1: The Monitor Object Pattern (Part 1)
  • Part 2: The Monitor Object Pattern (Part 2)
  • Module 2: Activating Services on Demand
  • Part 1: The Activator Pattern (Part 1)
  • Part 2: The Activator Pattern (Part 2)
  • Module 3: Passing Commands to Services
  • Part 1: The Command Processor Pattern (Part 1)
  • Part 2: The Command Processor Pattern (Part 2)
  • Module 4: Automating Marshaling and Demarshaling of Data
  • Part 1: The Proxy Pattern (Part 1)
  • Part 2: The Proxy Pattern (Part 2)
  • Module 5: Supporting Object-Oriented Remote Method Calls
  • Part 1: The Broker Pattern (Part 1)
  • Part 2: The Broker Pattern (Part 2)
  • Module 6: Decoupling Producers from Consumers
  • Part 1: The Publisher-Subscriber Pattern (Part 1)
  • Part 2: The Publisher-Subscriber Pattern (Part 2)
  • Module 7: Ensuring Only One Looper Per Thread
  • Part 1: The Thread-Specific Storage Pattern
  • Module 8: Passing Message Requests Between Threads
  • Part 1: The Active Object Pattern
  • Module 9: Decoupling Synchronous & Synchronous Processing
  • Part 1: the Half-Sync/Half-Async Pattern

Throughout the MOOC we'll focus on pattern-oriented software architecture, with an emphasis on concurrent and networked programming in the context of Android middleware systems programming mechanisms, such as synchronous and asynchronous concurrency models, background service processing, storage and retrieval of structured data, and local inter-process communication (IPC) and networking. We illustrate by example how key pattern and framework concepts and relationships are applied in Android Services, Content Providers, Broadcast Receivers, and various secure local and remote IPC mechanisms from both an application and infrastructure perspective. Many code examples are shown throughout using Java, with a case study project used to reify the key points throughout all the modules in this section.

The PDF versions of all the slides used in the course will be available online as the videos become available on the course website.