Start a New Activity with Intent in Kotlin Android

You will learn how Android uses an explicit Intent to open another screen, why Kotlin requires a class reference rather than a class name, and how to ensure the destination Activity is configured correctly.

An Android Activity represents a screen, such as a login screen, settings screen, or product-details screen. To move from one Activity to another, create an explicit Intent.

An explicit Intent identifies the exact destination Activity class:

Intent(currentContext, DestinationActivity::class.java)

In the original code, Page2 is only the name of a Kotlin class. Intent needs Java's runtime class representation, written in Kotlin as Page2::class.java.

This distinction matters because Android must know exactly which Activity component it should create and display. The Intent carries that destination information to Android's Activity system, and startActivity() asks the system to open it.

Think of an Intent as an addressed envelope.

• The current Activity (this) is the return address and application context.
• The destination Activity class (Page2::class.java) is the recipient's address.
• startActivity(intent) hands the envelope to Android's delivery system.

Writing only Page2 is like writing the name of a building without supplying its actual address format. Page2::class.java gives Android the destination type it needs.

The standard Kotlin syntax for opening another Activity is:

val intent = Intent(this, DestinationActivity::class.java)
startActivity(intent)

For this example, use Page2::class.java:

import android.content.Intent
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {

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

    fun buTestUpdateText2(view: View) {
        val changePage = Intent(this, Page2::class.java)
        startActivity(changePage)
    }
}

The destination must be an Activity class:

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class Page2 : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_page2)
    }
}

::class creates a Kotlin class reference. Adding .java converts it to the Class object expected by the Android Intent constructor.

Consider this click handler:

fun openPage2(view: View) {
    val intent = Intent(this, Page2::class.java)
    startActivity(intent)
}

Execution proceeds as follows:

1. The user taps the view connected to openPage2.
2. this refers to the current MainActivity instance.
3. Page2::class.java identifies the Page2 Activity class.
4. Intent(this, Page2::class.java) creates an explicit navigation request.
5. startActivity(intent) sends the request to Android.
6. Android creates or resumes Page2 and calls its lifecycle methods, including onCreate() when a new instance is needed.
7. The Page2 layout becomes visible.

When the user presses the system Back button, Android usually finishes Page2 and returns to MainActivity.

Activities are often used for navigation between larger, independent screens, including:

• Opening a settings screen from a profile page.
• Moving from a sign-in screen to a main dashboard.
• Opening a product detail screen after a user selects an item.
• Launching a checkout or payment flow.
• Opening a separate camera, map, or document-preview Activity.

An Intent can also carry small pieces of data to the next screen:

val intent = Intent(this, Page2::class.java)
intent.putExtra("USER_ID", 42)
startActivity(intent)

Page2 can read that value from intent in its onCreate() method.

In real Android projects, explicit Intents are commonly kept close to UI event handling, while the destination receives validated input.

A typical sender pattern is:

fun openProfile(userId: String) {
    if (userId.isBlank()) return

    val intent = Intent(this, ProfileActivity::class.java)
        .putExtra(ProfileActivity.EXTRA_USER_ID, userId)

    startActivity(intent)
}

A destination Activity commonly defines keys as constants so that the sender and receiver use the same key:

class ProfileActivity : AppCompatActivity() {
    companion object {
        const val EXTRA_USER_ID = "extra_user_id"
    }
}

For larger apps, developers may add a factory function in the destination's companion object to centralize Intent creation:

class ProfileActivity : AppCompatActivity() {
    companion object {
        const val EXTRA_USER_ID = "extra_user_id"

        fun newIntent(context: Context, userId: String): Intent {
            return Intent(context, ProfileActivity::class.java)
                .putExtra(EXTRA_USER_ID, userId)
        }
    }
}

Then the caller uses startActivity(ProfileActivity.newIntent(this, userId)). This avoids repeating extra keys and makes navigation safer to update.

Passing the class name instead of a class reference

Incorrect:

val intent = Intent(this, Page2)

Page2 is a class declaration, not the Class value the constructor expects.

Correct:

val intent = Intent(this, Page2::class.java)

Instantiating an Activity yourself

Avoid this:

val page = Page2()

Android manages Activity creation and lifecycle callbacks. Create an Intent and call startActivity() instead.

Forgetting to make the destination an Activity

This will not work as a destination if Page2 is an ordinary Kotlin class:

class Page2

It should extend an Android Activity type, for example:

class Page2 : AppCompatActivity()

Missing the manifest declaration

An Activity normally must be declared in AndroidManifest.xml, especially if it was not created using Android Studio's Activity template:

<application ...>
    <activity android:name=".Page2" />
    <activity android:name=".MainActivity" android:exported="true">
        <!-- launcher intent filter -->
    </activity>
</application>

If it is missing, the app can compile but fail at runtime with an Activity-not-found error.

Using the wrong context

Inside an Activity, this is appropriate. In a Fragment, use requireContext() or often call the Fragment's startActivity():

startActivity(Intent(requireContext(), Page2::class.java))

Do not use an uninitialized or unrelated context.

An implicit Intent example:

val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://developer.android.com"))
startActivity(intent)

Unlike an explicit Intent, this does not name a specific Activity class. Android finds an installed app that can handle the action.

// Open an Activity from another Activity
startActivity(Intent(this, Page2::class.java))

// Create the Intent first
val intent = Intent(this, Page2::class.java)
startActivity(intent)

// Send data
val intent = Intent(this, Page2::class.java)
intent.putExtra("KEY", "value")
startActivity(intent)

// Read data in the destination Activity
val value = intent.getStringExtra("KEY")

Rules:

• Use DestinationActivity::class.java, not just DestinationActivity.
• The destination must extend Activity or AppCompatActivity.
• Let Android create Activities; do not call an Activity constructor directly.
• Declare manually created Activities in AndroidManifest.xml.
• Use this inside an Activity and requireContext() inside a Fragment.

Why does Kotlin require ::class.java when starting an Activity?

The Intent constructor expects a Java Class object for its destination. Page2::class.java supplies that object.

Can I use Page2::class without .java?

Not with the standard Intent(context, class) constructor. It expects Class<*>, so use Page2::class.java.

Does Page2 need to extend AppCompatActivity?

It must extend an Android Activity class. AppCompatActivity is a common choice because it provides compatibility features and works with AndroidX.

Why does the app crash after I fix the Kotlin error?

Check that Page2 is declared in AndroidManifest.xml. A missing declaration can cause Android to throw an Activity-not-found exception.

How do I open an Activity from a Fragment?

Use a valid Fragment context:

startActivity(Intent(requireContext(), Page2::class.java))

How do I pass information to the next Activity?

Add extras with putExtra() before calling startActivity(), then read them from the destination Activity's intent.

Should every Android screen be an Activity?

Not necessarily. Many modern apps use one Activity with multiple Fragments or Jetpack Compose navigation. Explicit Intents remain the standard way to launch another Activity.

• Kotlin class references — Learn why MyClass::class and MyClass::class.java represent a type at runtime.
• Android Activity lifecycle — Understand what happens when Android creates, pauses, resumes, and destroys screens.
• AndroidManifest.xml — Learn how Android discovers application components such as Activities.
• Intent extras — Pass identifiers, text, and other small values between Activities.
• Fragments — A common way to represent screens or sections of a screen within an Activity.
• Jetpack Compose Navigation — A modern navigation approach for Compose-based Android interfaces.
• Implicit Intents — Ask Android to perform an action, such as sharing text or opening a web page.