Android 12 Analog and Digital Clock Live Wallpaper – Android 12 Clock Widgets – Admob Ads

Introduction

Android 12 brings a slew of exciting features, one of which is the Analog and Digital Clock Live Wallpaper. In this tutorial, we'll dive into how to use the Android 12 Clock Widget and incorporate AdMob ads to monetize your app. Whether you're a developer looking to add some functionality to your app or simply interested in creating a unique wallpaper experience, this guide will walk you through each step.

Prerequisites

To follow along, you'll need:

• Android Studio or any other Android IDE
• Java or Kotlin language proficiency (we'll be using Kotlin in this tutorial)
• A basic understanding of Android app development concepts
• A testing device with Android 12 or higher installed
• An AdMob account

Setting up the Analog and Digital Clock Live Wallpaper

Before we begin, let's clarify what this wallpaper does: it combines both analog and digital clock modes in a single widget. You can switch between modes, change the clock's hands color, and even set up the analog clock's hands alignment. For this tutorial, we'll be creating a basic implementation to demonstrate how to use the clock and incorporate AdMob ads.

Step 1: Creating a new Android project in Android Studio

Launch Android Studio and click on "Start a new Android Studio project."

Choose the following settings:

• Package name: com.example.clock_wallpaper
• Save location: Where you'd like to save your project (e.g., C:Users<username>clock_wallpaper)
• Language: Kotlin
• Minimum SDK: 32 (Android 12)

Step 2: Designing the Analog and Digital Clock

In your project directory, open the activity_main.xml file and design your UI layout. For a basic setup, you can use the following code:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical">

    <View
        android:layout_width="300dp"
        android:layout_height="200dp"
        android:id="@+id/clock_frame"

        />

</LinearLayout>

Here, we've created a LinearLayout and placed a View inside it to create a basic layout for our clock.

Step 3: Implementing the Analog Clock

To draw the analog clock, create a new class called AnalogClock.java. Add the following code:

class AnalogClock(context: Context?, attributeSet: AttributeSet?) :
    View(context, attributeSet) {

    private var hours = 0
    private var minutes = 0
    private var seconds = 0
    private var hourHandStart = 270
    private var hourHandLength = 80
    private var hourHandWidth = 10
    private var minuteHandStart = 270
    private var minuteHandLength = 100
    private var minuteHandWidth = 3
    private var secondHandStart = 270
    private var secondHandLength = 90
    private var secondHandWidth = 2

    init {
        invalidate()
    }

    override fun onDraw(canvas: Canvas?) {
        super.onDraw(canvas)

        val centerXY = getWidth() / 2
        val radius = Math.min(getWidth() / 2, getHeight() / 2)

        // Draw center
        canvas!!.drawCircle(centerXY.toFloat(), centerXY.toFloat(), radius - 5, Paint().also {
            it.color = Color.BLACK
            it.style = Paint.Style.STROKE
        })

        // Draw hour hand
        val hourHandPaint = Paint().apply {
            this.color = Color.BLACK
            this.strokeWidth = hourHandWidth.toFloat()
            this.style = Paint.Style.FILL
        }
        val hoursPositionX = centerXY + (radius - hourHandLength).toFloat() *
                (hourHandStart + hours * 30 + minutes * 0.5f).toInt()
           .div(360)
        val hoursPositionY = centerXY -
                (radius - hourHandLength).toFloat() +
                (hourHandStart + hours * 30 + minutes * 0.5f).toInt()
           .div(360)
        canvas.drawLine(
            centerXY.toFloat(), centerXY.toFloat(),
            hoursPositionX.toFloat(), hoursPositionY.toFloat(),
            hourHandPaint
        )

        // Draw minute hand
        val minuteHandPaint = Paint().apply {
            this.color = Color.BLACK
            this.strokeWidth = minuteHandWidth.toFloat()
            this.style = Paint.Style.FILL
        }
        val minutePositionX = centerXY + (radius - minuteHandLength).toFloat() *
                (minuteHandStart + minutes * 6 + seconds * 0.1f).toInt()
           .div(360)
        val minutePositionY = centerXY -
                (radius - minuteHandLength).toFloat() +
                (minuteHandStart + minutes * 6 + seconds * 0.1f).toInt()
           .div(360)
        canvas.drawLine(
            centerXY.toFloat(), centerXY.toFloat(),
            minutePositionX.toFloat(), minutePositionY.toFloat(),
            minuteHandPaint
        )

        // Draw second hand
        val secondHandPaint = Paint().apply {
            this.color = Color.BLACK
            this.strokeWidth = secondHandWidth.toFloat()
            this.style = Paint.Style.FILL
        }
        val secondPositionX = centerXY + (radius - secondHandLength).toFloat() *
                (secondHandStart + seconds * 6).toInt().div(360)
        val secondPositionY = centerXY -
                (radius - secondHandLength).toFloat() +
                (secondHandStart + seconds * 6).toInt().div(360)
        canvas.drawLine(
            centerXY.toFloat(), centerXY.toFloat(),
            secondPositionX.toFloat(), secondPositionY.toFloat(),
            secondHandPaint
        )

    }
}

This code handles drawing the analog clock hands based on the hours, minutes, and seconds.

Step 4: Adding the Analog Clock to Your Activity

Open your MainActivity class and add the following code:

import androidx.appcompat.app.AppCompatActivity

import android.os.Bundle

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Get the clock_frame View
        val clockFrameView: View = findViewById(R.id.clock_frame)
        clockFrameView.layoutParams = LinearLayout.LayoutParams(
            LayoutParams.WRAP_CONTENT,
            LayoutParams.WRAP_CONTENT
        )
        clockFrameView.viewTreeObserver.addOnPreDrawListener {
            // Pass the canvas and get the dimensions for the Analog Clock
            val canvas: Canvas? = clockFrameView.drawable?.initCanvas()
            // Validate if canvas is not null
            canvas?.let { drawAnalogClock(it, it.width, it.height) }
            true
        }
    }
}

Here, we get the clock_frame View from your activity_main.xml layout and call addOnPreDrawListener() on its ViewTreeObserver. This gets the Canvas and performs the analog clock drawing using the drawAnalogClock method.

Step 5: Creating a Basic Digital Clock

Now, create a new class called DigitalClock.java to display the digital clock:

class DigitalClock(context: Context?, attributeSet: AttributeSet?) :
    TextView(context, attributeSet) {

    constructor(context: Context?) : this(context, null)
    constructor(context: AttributeSet?) : this(context, context.attributesXml)
    constructor(context: AttributeSet?, defStyleAttr: Int) : super(
        context,
        defStyleAttr
    ) {}

    private lateinit var clock: Clock
    private var hours = 0
    private var minutes = 0
    private var seconds = 0

    init {
        typeface = Typeface.DEFAULT
        setTextSize(25f)
    }

    fun displayClock(clock: Clock) {
        hours = clock.getHour()
        minutes = clock.getMinute()
        seconds = clock.getSecond()

        val text = if (hours > 12) {
            "${hours - 12}:${stringFormat("%02d", minutes)}${if (hours!= 12 && hours!= 13) " " else ""}$if (hours > 12) "PM" else "AM"
        } else {
            "${hours}:${stringFormat("%02d", minutes)}${if (hours > 12) " AM" else ""}"
        }
        setText(text)
    }
}

Step 6: Adding the Digital Clock to Your Activity

Open your MainActivity class and add the following code:

// Initialize the Digital Clock and draw the initial time
val digitalClock = DigitalClock(this)
digitalClock.setTextSize(40f)
digitalClock.setTextColor(Color.BLACK)
val params = LinearLayout.LayoutParams(
    LinearLayout.LayoutParams.WRAP_CONTENT,
    LinearLayout.LayoutParams.WRAP_CONTENT
)
params.gravity = Gravity.CENTER
clockFrameView.layoutParams = params
clockFrameView.addView(digitalClock)
clockFrameView.viewTreeObserver.addOnPreDrawListener {
    val canvas: Canvas? = clockFrameView.drawable?.initCanvas()
    // Validate if canvas is not null
    canvas?.let { digitalClock.displayClock(Clock(calendar.timeInMillis)) }
    true
}

Here, we get a reference to the Digital Clock class, add it to the LinearLayout, and then update the time periodically.

Step 7: Enabling AdMob Ads

Download the AdMob SDK from the Google Cloud Console and integrate it into your project:

• Go to the AdMob dashboard and create a new ad unit for both banners and interstitial ads
• Add the following lines to your build.gradle file:

dependencies {
    implementation 'com.google.android.gms:play-services-ads:21.2.0'
    implementation 'com.google.firebase:firebase-messaging:23.0.5'
}

• Initialize the ad views in your MainActivity:

val bannerAdView = AdView(context)
bannerAdView.adUnitId = "YOUR_BANNER_AD_UNIT_ID"
bannerAdView.adSize = AdSize.BANNER

val interstitialAd = InterstitialAd(context)
interstitialAd.setAdUnitId("YOUR_INTERSTICIAL_AD_UNIT_ID")

interstitialAd.loadAd AdRequest.Builder().build()

In this step, we've set up our AdMob ad units and initialized our ad views. This will allow us to show ads in our app.

Step 8: Testing the Clock Wallpaper

After setting up the analog and digital clock, test the wallpaper by running your app and adjusting the hands of the analog clock manually.

Now that you've got a basic analog and digital clock widget up and running, you can further customize its appearance, add animations, and incorporate the ad views into your app. In this tutorial, we've covered the core aspects of setting up the clock widget and including AdMob ads.