Wake Up Battle Android Game

Innovative app and game development with multiplayer capability

As part of a team project, we developed “Wake Up Battle,” an innovative Android gaming application designed to motivate users to wake up early through competitive gameplay. This comprehensive alarm game combined social features with gamification, allowing players to challenge friends in morning wake-up competitions while earning currency and unlocking customizable content.

The application featured a unique concept where setting and responding to alarms becomes a competitive multiplayer experience. Players could create or join groups, compete for the best wake-up times, earn points through successful alarm responses, and customize their gaming experience with unlockable backgrounds and items. The project demonstrated modern software development practices including agile methodology, GitLab version control, CI/CD pipelines, and comprehensive testing with Mockito framework.

Table of Contents

  1. Main Goals
  2. Technical Architecture
  3. Development Methodology
  4. Technical Challenges and Solutions
  5. Project Deliverables
  6. Learning Outcomes
  7. Project Impact
  8. Code Implementation Examples
  9. Application Screenshots and Features

Main Goals

  1. Develop a complete Android gaming application
    • Create an engaging battle game with intuitive user interface
    • Implement user authentication and profile management system
    • Design and implement leaderboard functionality with real-time updates
    • Develop both single-player and multiplayer game modes

  2. Implement modern software development practices
    • Utilize Git for version control with collaborative development
    • Apply agile methodology with regular sprints and team meetings
    • Implement comprehensive testing with Mockito framework
    • Follow CI/CD practices for continuous integration and deployment

  3. Build scalable backend infrastructure
    • Design and implement secure user authentication system
    • Create database architecture for user profiles and game data
    • Implement RESTful API for frontend-backend communication
    • Develop leaderboard system with real-time score tracking

Technical Architecture

Frontend Development (Android)

The Android application was built using modern Android development practices with extensive attention to UI/UX design:

  • Java-based Implementation: Core game logic, UI components, and comprehensive alarm management system
  • Volley Network Library: HTTP requests for backend communication with robust error handling
  • LRU Bitmap Cache: Efficient image loading and caching system for background customization features
  • Custom App Controller: Centralized application state management and network request handling
  • Constraint Layout Design: Advanced UI layouts supporting multiple screen configurations and device orientations
  • Material Design Components: TextInputLayout, button styling, and responsive design elements
  • Testing Integration: Mockito framework implementation for comprehensive unit testing coverage
Backend Infrastructure

The server-side implementation focused on scalability, security, and real-time game mechanics:

  • Spring Boot Framework: Robust RESTful web services with comprehensive API endpoints
  • User Authentication: Secure login/register system with JWT tokens and password hashing
  • Database Management: MySQL schema design for user profiles, game statistics, group management, and leaderboard data
  • RESTful API: Clean interface supporting user management, game mechanics, group operations, and chat functionality
  • Real-time Features: Live leaderboard updates, group synchronization, and friend management system
  • Administrative Controls: Multi-tier user system with base users, admins, and VIP functionality
  • Game Logic Backend: Alarm verification, scoring algorithms, and competitive ranking systems
Development Tools and Practices

Modern software development methodology was employed throughout with industry-standard practices:

  • GitLab Version Control: Iowa State University GitLab server (git.linux.iastate.edu) with feature branching and merge requests
  • Agile Methodology: Weekly TA meetings, sprint planning, regular demos (Demo1, Demo2, Demo3, Demo4), and iterative development
  • Testing Framework: Mockito integration for Android unit testing with dependency injection and comprehensive test coverage
  • Build Management: Gradle dependency management with Android Studio and IntelliJ IDEA development environments
  • Quality Assurance: Peer code review, Git commit tracking, task board management, and systematic debugging practices
  • Project Documentation: Regular team meeting reports, CATME peer evaluations, and comprehensive progress tracking
  • Development Environment: Professional Android emulator setup, device testing, and production-ready deployment practices

Development Methodology

Agile Development Process

Our team followed a structured agile methodology with formal academic oversight:

  • Weekly TA Meetings: Regular Zoom sessions (3513022602) for progress reviews and technical guidance
  • Milestone Demos: Four formal demonstrations (Demo1-Demo4) showcasing incremental development progress
  • Sprint Planning: Iterative feature development with clear deliverables and timeline management
  • Task Board Management: GitLab Issues → Boards for tracking individual and team progress
  • Team Coordination: Regular standup meetings, progress updates, and collaborative problem-solving
  • Academic Integration: Course alignment with COM S 309 curriculum, peer evaluations, and formal assessments
Project Management

Systematic approach to project organization with academic rigor:

  • Role Specialization: Frontend specialists (Friends, Settings, Alarm pages), Backend development (Admin functionality, User management), Game Logic implementation
  • Progress Tracking: Canvas group wiki updates, regular milestone reviews, and formal team meeting documentation
  • Proposal Evolution: Iterative refinement from initial concept to detailed implementation plan with TA feedback integration
  • Risk Management: Technical challenge resolution (UI layout constraints, button styling, emulator configuration issues)
  • Documentation Standards: Professional project proposals, screen sketches, technical specifications, and comprehensive meeting reports
Quality Assurance

Rigorous testing and validation process:

  • Unit Testing: Mockito framework for component testing
  • Integration Testing: End-to-end system validation
  • User Acceptance Testing: Real-world scenario validation
  • Performance Testing: Load testing and optimization

Technical Challenges and Solutions

Android UI Layout and Constraint Management

Challenge: Complex UI layout positioning with TextInputLayout and constraint-based design Solution:

  • Resolved constraint layout positioning issues through XML attribute debugging
  • Implemented proper Material Design component integration with backgroundTint properties
  • Utilized constraint layout anchoring systems for responsive design across device configurations
  • Developed systematic approach to UI component positioning and styling
Android Emulator Configuration and Virtualization

Challenge: Android Studio emulator compatibility issues and hardware virtualization requirements Solution:

  • Configured AMD processor compatibility with Android Emulator Hypervisor Driver
  • Enabled BIOS-level virtualization settings for improved emulator performance
  • Implemented BlueStacks alternative emulation for development testing
  • Established device checkout procedures for physical Android testing hardware
Network Communication and SSL Handling

Challenge: HTTPS/HTTP request handling with Volley library and SSL certificate validation Solution:

  • Implemented cleartext traffic configuration for development environments
  • Resolved SSL handshake exceptions and certificate validation issues
  • Configured Android manifest for HTTP traffic permissions during testing phases
  • Developed robust error handling for network communication failures
Mockito Testing Framework Integration

Challenge: Unit testing implementation with Mockito framework in Android environment Solution:

  • Configured Gradle dependencies for Mockito integration with Android Studio
  • Resolved testImplementation vs testCompile dependency conflicts
  • Implemented comprehensive mocking strategies for Android component testing
  • Established automated testing pipeline with proper dependency injection
Git Workflow and Collaboration Management

Challenge: Multi-developer collaboration with GitLab version control and merge conflicts Solution:

  • Established systematic GitLab merge request workflows with code review processes
  • Implemented feature branching strategies for parallel development tracks
  • Configured Iowa State University GitLab server integration with VPN requirements
  • Developed commit tracking and activity monitoring for academic evaluation compliance

Project Deliverables

Core Application Features
  • Wake-Up Gaming System: Competitive alarm-based gameplay with morning wake-up challenges
  • User Authentication: Secure login/register system with multi-tier user roles (Base, Admin, VIP)
  • Group Management: Create/join competitive groups with team leader functionality and administrative controls
  • Friend Management System: Add friends, send requests, and build social gaming networks
  • Leaderboard System: Real-time rankings, scoring systems, and competitive achievement tracking
  • Chat Functionality: In-app messaging system for team coordination and social interaction
  • Customization Features: Background unlocking system, item store, and visual personalization options
  • Alarm Integration: Smart alarm system with game mechanics integration and wake-up verification
Screen Design and UI Architecture

Complex Screens (Advanced functionality and navigation):

  • Main In-Game Page with real-time game mechanics
  • Comprehensive Leaderboard with sorting and filtering
  • Group Leader Administrative Interface for team management
  • Group Creation Wizard with customizable settings
  • Friend Management System with search and request handling
  • Store/Items interface for virtual currency and unlockables
  • Administrative Controls for multi-tier user management

Supporting Screens (Core user flows):

  • Login/Register authentication interface
  • Settings and configuration management
  • Real-time chat messaging system
  • Game results and statistics display
  • Loading screens and user feedback interfaces
Technical Documentation
  • Screen Sketches: Complete UI/UX design documentation and wireframes
  • API Documentation: Comprehensive backend interface documentation
  • Project Proposals: Detailed technical specifications and iterative refinements
  • Testing Documentation: Mockito test cases and validation procedures
Development Artifacts
  • Source Code: Complete Java/Android implementation
  • Database Schema: User and game data architecture
  • Test Suite: Comprehensive testing framework
  • Deployment Scripts: CI/CD pipeline configuration

Learning Outcomes

This project significantly enhanced my technical and professional development:

Android Development Mastery:

  • UI/UX Design: Advanced constraint layout management, Material Design implementation, and responsive design principles
  • Framework Integration: Volley networking library, LRU bitmap caching, and custom app controller architecture
  • Testing Proficiency: Mockito framework implementation, dependency injection, and comprehensive unit testing strategies
  • Development Environment: Android Studio optimization, emulator configuration, and device testing procedures

Backend Development Skills:

  • Spring Boot Architecture: RESTful API design, database schema optimization, and security implementation
  • Database Management: MySQL integration, user management systems, and real-time data synchronization
  • Authentication Systems: JWT tokens, multi-tier user roles, and secure session management

Professional Development Practices:

  • Agile Methodology: Weekly TA meetings, formal demo presentations, and iterative development cycles
  • Version Control Expertise: GitLab workflow management, merge request processes, and collaborative development strategies
  • Problem-Solving Skills: Technical debugging (UI constraints, network protocols, emulator issues), systematic troubleshooting approaches
  • Academic Integration: Canvas project management, peer evaluation systems (CATME), and formal documentation standards
  • Team Leadership: Role specialization coordination, project proposal development, and cross-functional collaboration

Project Impact

This “Wake Up Battle” Android gaming application served as a comprehensive capstone experience for COM S 309, providing:

  • Full-Stack Mobile Development: End-to-end Android application with Spring Boot backend integration
  • Advanced UI/UX Implementation: Complex constraint layouts, Material Design components, and multi-screen navigation
  • Professional Development Practices: GitLab workflows, Mockito testing frameworks, and formal academic evaluation systems
  • Real-World Problem Solving: Technical debugging, emulator configuration, network protocol handling, and dependency management
  • Team Leadership and Collaboration: Agile methodology with TA oversight, formal presentations, and peer evaluation systems

The project demonstrated practical application of software engineering principles through iterative development, comprehensive testing, and professional documentation standards. The combination of technical challenges (UI constraints, SSL handling, testing framework integration) with academic rigor (formal demos, peer evaluations, proposal iterations) provided essential preparation for professional software development environments.

Code Implementation Examples

Android UI Layout with Constraint Management

Resolving the TextInputLayout positioning issues discussed in development:

<!-- activity_login.xml -->
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.google.android.material.textfield.TextInputLayout
        android:id="@+id/textInputUsername"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="32dp"
        android:layout_marginEnd="32dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintBottom_toTopOf="@+id/textInputPassword">
        
        <com.google.android.material.textfield.TextInputEditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Username" />
            
    </com.google.android.material.textfield.TextInputLayout>

    <Button
        android:id="@+id/btnLogin"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="Login"
        android:backgroundTint="@color/primary_color"
        app:layout_constraintTop_toBottomOf="@+id/textInputPassword"
        app:layout_constraintStart_toStartOf="@+id/textInputUsername"
        app:layout_constraintEnd_toEndOf="@+id/textInputUsername" />

</androidx.constraintlayout.widget.ConstraintLayout>
Custom App Controller with Volley Integration

Implementing centralized network request management:

public class AppController extends Application {
    private static AppController instance;
    private RequestQueue requestQueue;
    private LruBitmapCache lruBitmapCache;

    @Override
    public void onCreate() {
        super.onCreate();
        instance = this;
    }

    public static synchronized AppController getInstance() {
        return instance;
    }

    public RequestQueue getRequestQueue() {
        if (requestQueue == null) {
            requestQueue = Volley.newRequestQueue(getApplicationContext());
        }
        return requestQueue;
    }

    public LruBitmapCache getLruBitmapCache() {
        if (lruBitmapCache == null) {
            lruBitmapCache = new LruBitmapCache();
        }
        return lruBitmapCache;
    }

    public <T> void addToRequestQueue(Request<T> req, String tag) {
        req.setTag(tag);
        getRequestQueue().add(req);
    }
}
LRU Bitmap Cache Implementation

Memory-efficient image caching for background customization:

public class LruBitmapCache extends LruCache<String, Bitmap> 
        implements ImageLoader.ImageCache {
    
    public LruBitmapCache() {
        this(getDefaultLruCacheSize());
    }

    public LruBitmapCache(int maxSize) {
        super(maxSize);
    }

    @Override
    protected int sizeOf(String key, Bitmap value) {
        return value.getRowBytes() * value.getHeight() / 1024;
    }

    @Override
    public Bitmap getBitmap(String url) {
        return get(url);
    }

    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        put(url, bitmap);
    }

    public static int getDefaultLruCacheSize() {
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        final int cacheSize = maxMemory / 8;
        return cacheSize;
    }
}
Android Manifest Configuration

Resolving cleartext traffic and testing framework integration:

<!-- AndroidManifest.xml -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="edu.iastate.wakeupbattle">

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.SET_ALARM" />

    <application
        android:name=".AppController"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme"
        android:usesCleartextTraffic="true"
        android:exported="true">

        <activity 
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity android:name=".LoginActivity" android:exported="false" />
        <activity android:name=".GameActivity" android:exported="false" />
        <activity android:name=".LeaderboardActivity" android:exported="false" />
        
    </application>
</manifest>
Gradle Dependencies Configuration

Mockito testing framework integration:

// app/build.gradle
dependencies {
    implementation 'com.android.volley:volley:1.2.1'
    implementation 'com.google.android.material:material:1.4.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.1'
    
    // Testing dependencies
    testImplementation 'junit:junit:4.13.2'
    testImplementation 'org.mockito:mockito-core:3.12.4'
    testImplementation 'org.mockito:mockito-android:3.12.4'
    
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
    androidTestImplementation 'org.mockito:mockito-android:3.12.4'
}
Mockito Unit Testing Example

Comprehensive testing strategy implementation:

@RunWith(MockitoJUnitRunner.class)
public class GameManagerTest {
    
    @Mock
    private Context mockContext;
    
    @Mock
    private RequestQueue mockRequestQueue;
    
    @InjectMocks
    private GameManager gameManager;
    
    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }
    
    @Test
    public void testAlarmVerification() {
        // Given
        User testUser = new User("testUser", "password");
        AlarmEvent alarmEvent = new AlarmEvent(System.currentTimeMillis());
        
        // When
        boolean result = gameManager.verifyAlarmResponse(testUser, alarmEvent);
        
        // Then
        assertTrue("Alarm verification should succeed for valid input", result);
        verify(mockRequestQueue).add(any(Request.class));
    }
    
    @Test
    public void testLeaderboardUpdate() {
        // Given
        int expectedScore = 100;
        String userId = "user123";
        
        // When
        gameManager.updateLeaderboard(userId, expectedScore);
        
        // Then
        verify(mockRequestQueue).add(argThat(request -> 
            request.getUrl().contains("/api/leaderboard/update")));
    }
}

Application Screenshots and Features


Core Application Interface: User Authentication, Main Dashboard, Settings Configuration, and Administrative Controls - Essential user interface and management components
Game Features and Management: Background Customization, Alarm System Interface, and Team Leadership - Personalization and advanced user roles
Interactive Features: Gameplay Demonstration, Chat Functionality, and Friend Management System - Real-time multiplayer capabilities and social networking features

This project was completed as part of COM S 309 (Software Development Practices) at Iowa State University.