> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Auth0.Android SDK を使用して Android アプリケーションにログイン機能を追加する

export const HowToSchema = () => <script type="application/ld+json">
    {'{"@context":"https://schema.org","@type":"HowTo"}'}
  </script>;

<HowToSchema />

<Accordion title="AI を使って Auth0 を統合する" icon="microchip-ai" iconType="solid" defaultOpen>
  Claude Code、Cursor、GitHub Copilot などの AI コーディングアシスタントを使用している場合は、[agent skills](https://agentskills.io/home) を使って、数分で Auth0 認証を自動的に追加できます。

  **インストール:**

  ```bash theme={null}
  npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-android
  ```

  **次に、AI アシスタントに次のように依頼します。**

  ```text theme={null}
  Add Auth0 authentication to my Android app
  ```

  AI アシスタントが、Auth0 アプリケーションの作成、認証情報の取得、Auth0 Android SDK 依存関係の追加、manifest プレースホルダーの設定、ログイン/ログアウトフローの実装を自動で行います。[agent skills の完全なドキュメント →](/ja/docs/quickstart/agent-skills)
</Accordion>

<div id="get-started">
  ## はじめに
</div>

<Steps>
  <Step title="新しい Android プロジェクトを作成する" stepNumber={1}>
    このクイックスタート用に、新しい Android プロジェクトを作成します。

    **Android Studio で:**

    1. **File** → **New** → **New Project**
    2. **Phone and Tablet** → **Empty Activity** テンプレートを選択します
    3. 次のようにプロジェクトを設定します。
       * **Name**: `Auth0-Android-Sample`
       * **Package name**: `com.auth0.samples.android`
       * **Language**: **Kotlin**
       * **Minimum SDK**: **API 24 (Android 7.0)**
       * **Build configuration language**: **Kotlin DSL**
    4. **Finish** をクリックします

    <Tip>
      これにより、現在の Android 開発のベストプラクティスに沿った、Kotlin と Gradle Kotlin DSL を使用するモダンな Android アプリが作成されます。
    </Tip>
  </Step>

  <Step title="Gradle で Auth0 SDK を追加する" stepNumber={2}>
    Gradle を使用して、Auth0 Android SDK をプロジェクトに追加します。

    **アプリ レベルの `build.gradle.kts` ファイルを更新します。**

    ```kotlin app/build.gradle.kts lines theme={null}
    dependencies {   
        // Auth0 SDK
        implementation("com.auth0.android:auth0:3.14.0")
    }
    ```

    **アプリレベルの`build.gradle.kts`にマニフェスト プレースホルダーを追加します。**

    ```kotlin app/build.gradle.kts lines theme={null}
    android {
        defaultConfig {
            // これらのマニフェストプレースホルダーを追加する
            manifestPlaceholders += mapOf(
                "auth0Domain" to "@string/com_auth0_domain", // 次のステップで設定する
                "auth0Scheme" to "https"
            )
        }
    }

    ```

    **`AndroidManifest.xml` にインターネットのアクセス許可を追加します。**

    ```xml app/src/main/AndroidManifest.xml lines theme={null}
    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools">
        <uses-permission android:name="android.permission.INTERNET" />
    </manifest>
    ```

    <Tip>
      Auth0 SDK は依存関係を自動的に解決し、トークンを安全に保存する機能を備えています。
    </Tip>
  </Step>

  <Step title="Auth0アプリを設定する" stepNumber={3}>
    次に、Auth0テナントで新しいアプリを作成し、その設定をAndroidプロジェクトに追加します。

    まず、`app/src/main/res/values/strings.xml` ファイルにプレースホルダー値を設定します。

    ```xml app/src/main/res/values/strings.xml theme={null}
    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="com_auth0_domain">{yourDomain}</string>
        <string name="com_auth0_client_id">YOUR_AUTH0_CLIENT_ID</string>
        <string name="com_auth0_scheme">https</string>
    </resources>
    ```

    1. [Auth0 Dashboard](https://manage.auth0.com/dashboard/)に移動します
    2. **Applications** > **Applications** > **Create Application** をクリックします
    3. ポップアップでアプリの名前を入力し、アプリの種類として `Native` を選択して **Create** をクリックします
    4. Application Details ページで **Settings** タブに切り替えます
    5. `strings.xml` ファイル内の `{yourDomain}` と `YOUR_AUTH0_CLIENT_ID` を、ダッシュボードの **Domain** と **クライアントID** の値に置き換えます

    最後に、Application Details ページの **Settings** タブで、次の URL を設定します。

    **Allowed Callback URLs:**

    ```
    https://{yourDomain}/android/PACKAGE_NAME/callback
    ```

    **許可済みのログアウト URL:**

    ```
    https://{yourDomain}/android/PACKAGE_NAME/callback
    ```

    `{yourDomain}` を実際の Auth0 ドメイン (例: `dev-abc123.us.auth0.com`) に置き換えてください。

    <Info>
      **Allowed Callback URLs** は、認証後にユーザーを安全にアプリケーションへ戻すための重要なセキュリティ対策です。一致する URL がない場合、ログイン処理は失敗し、ユーザーはアプリにアクセスできず、代わりに Auth0 のエラーページが表示されます。

      **Allowed Logout URLs** は、サインアウト時にシームレスなユーザー体験を提供するうえで重要です。一致する URL がない場合、ログアウト後にユーザーはアプリケーションへリダイレクトされず、代わりに汎用的な Auth0 ページに遷移します。

      URL スキームには、コールバックが対象のアプリにルーティングされるよう、パッケージ名 (`com.auth0.samples.android`) が含まれています。
    </Info>

    <Warning>
      **重要**: コールバック URL 内のパッケージ名が、`build.gradle.kts` の `applicationId` と一致していることを確認してください。認証に失敗する場合は、これらの値が同一かどうかを確認してください。
    </Warning>

    <Tip>
      `https` スキーム (上記で設定) を使用する場合は、コールバック URL がブラウザーではなくアプリに直接ルーティングされるよう、Android App Links を設定する必要があります。詳細は、以下の [Troubleshooting & Advanced](#troubleshooting--advanced) にある **Configure Android App Links** セクションを参照してください。
    </Tip>
  </Step>

  <Step title="Auth0 SDKを初期化する" stepNumber={4}>
    Activity で Auth0 と通信するための Auth0 インスタンスを作成します。

    **`MainActivity.kt` で:**

    ```kotlin MainActivity.kt lines theme={null}
    import com.auth0.android.Auth0
    import com.auth0.android.authentication.AuthenticationException
    import com.auth0.android.callback.Callback
    import com.auth0.android.provider.WebAuthProvider
    import com.auth0.android.result.Credentials

    class MainActivity : ComponentActivity() {
        private lateinit var auth0: Auth0

        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            
            // Auth0を初期化する
            auth0 = Auth0.getInstance(
                getString(R.string.com_auth0_client_id),
                getString(R.string.com_auth0_domain)
            )
        }
    }
    ```

    <Tip>
      Auth0 インスタンスは、前の手順で設定した `strings.xml` ファイル内のクライアントIDとドメインを使用して初期化されます。このインスタンスは、以降のすべての認証処理で使用されます。
    </Tip>
  </Step>

  <Step title="ログインとログアウトの実装" stepNumber={5}>
    **ログインを実装する:** WebAuthProvider を使用して Universal Login ページを起動します。

    次のメソッドを `MainActivity` に追加します。

    <Tabs>
      <Tab title="Kotlin コールバック">
        ```kotlin MainActivity.kt lines theme={null}
        private fun login() {
            WebAuthProvider.login(auth0)
                .withScheme("https")
                .withScope("openid profile email offline_access")
                .start(this, object : Callback<Credentials, AuthenticationException> {
                    override fun onSuccess(credentials: Credentials) {
                        // 認証情報を保存する
                        // ユーザーは認証済み
                    }

                    override fun onFailure(exception: AuthenticationException) {
                        // エラーを処理する
                    }
                })
        }
        ```
      </Tab>

      <Tab title="コルーチン">
        ```kotlin MainActivity.kt lines theme={null}
        private fun login() {
            lifecycleScope.launch {
                try {
                    val credentials = WebAuthProvider.login(auth0)
                        .withScheme("https")
                        .withScope("openid profile email offline_access")
                        .await(this@MainActivity)
                    // 認証情報を保存する
                    // ユーザーは認証済み
                } catch (exception: AuthenticationException) {
                    // エラーを処理する
                }
            }
        }
        ```
      </Tab>
    </Tabs>

    **ログアウトを実装する:** WebAuthProvider を使用してユーザーのセッションをクリアします。

    <Tabs>
      <Tab title="Kotlin コールバック">
        ```kotlin MainActivity.kt lines theme={null}
        private fun logout() {
            WebAuthProvider.logout(auth0)
                .withScheme("https")
                .start(this, object : Callback<Void?, AuthenticationException> {
                    override fun onSuccess(result: Void?) {
                        // 保存した認証情報をクリアする
                        // ユーザーはログアウト済み
                    }

                    override fun onFailure(exception: AuthenticationException) {
                        // エラーを処理する
                    }
                })
        }
        ```
      </Tab>

      <Tab title="コルーチン">
        ```kotlin MainActivity.kt lines theme={null}
        private fun logout() {
            lifecycleScope.launch {
                try {
                    WebAuthProvider.logout(auth0)
                        .withScheme("https")
                        .await(this@MainActivity)
                    // 保存した認証情報をクリアする
                    // ユーザーはログアウト済み
                } catch (exception: AuthenticationException) {
                    // エラーを処理する
                }
            }
        }
        ```
      </Tab>
    </Tabs>

    <Info>
      `login()` メソッドと `logout()` メソッドは、UI 内の対応するボタンをユーザーがタップしたときに呼び出してください。このコードでは、コンテキストパラメーターとして `this` (Activity を参照) を使用しています。これは、WebAuthProvider が Chrome Custom Tabs を起動し、認証フローを処理するために必要です。
    </Info>
  </Step>

  <Step title="アプリを実行" stepNumber={6}>
    Android アプリをビルドして実行します。

    **Android Studio で:**

    ```shellscript theme={null}
    # Gradleファイルとプロジェクトを同期する（またはAndroid Studioの「Sync Now」を使用）
    ./gradlew clean build

    # 接続されたデバイスまたはエミュレーターにビルドしてインストールする
    ./gradlew installDebug

    # またはAndroid Studioから直接実行する
    # 「Run」ボタンをクリックするか、Shift+F10を押す
    ```

    **想定されるフロー:**

    1. アプリが「ログイン」ボタンとシールドアイコン付きで起動する
    2. 「ログイン」をタップ → Chrome Custom Tab が開く → ログインを完了
    3. 自動的にアプリに戻る
    4. 成功!!

    <Warning>
      Android では、複数のブラウザーがインストールされている場合、ブラウザーの選択ダイアログが表示されます。Auth0 の認証では、Chrome Custom Tabs を使用することで最適なユーザー体験が得られます。
    </Warning>
  </Step>
</Steps>

<Check>
  **チェックポイント**

  これで、Android デバイスまたはエミュレーター上で、Auth0 のログイン機能が完全に動作するようになっているはずです。アプリは安全な認証のために Chrome Custom Tabs を使用し、認証情報を自動的に保存します。
</Check>

***

<div id="troubleshooting-advanced">
  ## トラブルシューティングと高度な設定
</div>

<Accordion title="よくある問題と解決策">
  ### Chrome Custom Tab からアプリにリダイレクトされない

  **解決策:**

  1. Auth0 Dashboard の **Allowed Callback URLs** が `applicationId` と完全に一致していることを確認します
  2. `build.gradle.kts` の manifest placeholders が正しく設定されていることを確認します
  3. HTTPS とカスタムスキーム URL の両方が設定されていることを確認します
  4. クリーンして再ビルドします: **Build** → **Clean Project** → **Rebuild Project**

  ### アプリがクラッシュする: 'Auth0 domain not found'

  **修正方法:**

  1. `com_auth0_domain` と `com_auth0_client_id` の値が正しいことを確認します
  2. ドメインの形式にタイプミスがないことを確認します (`https://` は含めないでください)

  ### 依存関係に関するビルドエラー

  **修正方法:**

  1. `build.gradle` (プロジェクトレベル) で Android Gradle Plugin を最新バージョンに更新します
  2. プロジェクトを同期します: **File** → **Sync Project with Gradle Files**
  3. ビルドをクリーンします: `./gradlew clean build`

  ### ユーザーによって認証がキャンセルされた

  エラーコールバックで適切に処理してください:

  ```kotlin {3,4,5,6} expandable theme={null}
  override fun onFailure(exception: AuthenticationException) {
      when {
          exception.isAuthenticationCanceled -> 
              showMessage("Login was cancelled")
          exception.isBrowserAppNotAvailable -> 
              showMessage("No browser available")
          else -> 
              showMessage("Login failed: ${exception.getDescription()}")
      }
  }
  ```

  ### 互換性のあるブラウザーがないというエラー

  * デバイスまたはエミュレーターに Chrome または別のモダンブラウザーをインストールします
  * より良いユーザー体験のために Chrome Custom Tabs を有効にします
  * Chrome がインストールされた実機でテストします
</Accordion>

<Accordion title="Android App Links を設定する">
  [Android App Links](https://developer.android.com/training/app-links) を使用すると、Auth0 コールバック URL のデフォルトハンドラーとしてアプリを指定できるため、より安全でシームレスな認証体験を実現できます。App Links を使用しない場合、Android によって、アプリとブラウザーのどちらを使用するかをユーザーに選ばせるダイアログが表示されることがあります。

  <Note>
    App Links では、検証済みの `https` スキームのコールバックを使用します。これは、[クライアントなりすまし攻撃](https://datatracker.ietf.org/doc/html/rfc8252#section-8.6) を受ける可能性があるカスタム URL スキームよりも安全です。
  </Note>

  ### 署名証明書のフィンガープリントを取得する

  アプリの署名証明書の SHA256 フィンガープリントが必要です。ターミナルで次のコマンドを実行します:

  ```shellscript theme={null}
  # デバッグビルド用
  keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

  # リリースビルド用
  keytool -list -v -keystore my-release-key.keystore
  ```

  出力から **SHA256** フィンガープリントの値をコピーします。

  ### Auth0 Dashboard で設定する

  1. [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) に移動し、アプリケーションを選択します
  2. **Settings** ページの一番下までスクロールして、**Show Advanced Settings** を選択します
  3. **Device Settings** タブを選択します
  4. **Android** で次の情報を入力します:
     * **App Package Name**: `applicationId` (例: `com.auth0.samples.android`)
     * **SHA256 Cert Fingerprints**: 上でコピーしたフィンガープリント
  5. **Save Changes** をクリックします

  ### 設定を確認する

  Auth0 は、Android がアプリを検証するために使用する `assetlinks.json` ファイルを自動的に生成します。次の URL にアクセスして確認してください:

  ```
  https://{yourDomain}/.well-known/assetlinks.json
  ```

  パッケージ名と証明書のフィンガープリントを含む JSON レスポンスが表示されるはずです:

  ```json theme={null}
  [{
    "relation": ["delegate_permission/common.handle_all_urls"],
    "target": {
      "namespace": "android_app",
      "package_name": "[YOUR_PACKAGE_NAME]",
      "sha256_cert_fingerprints": ["YOUR_SHA256_FINGERPRINT"]
    }
  }]
  ```

  <Info>
    このクイックスタートでは、manifest placeholders と `WebAuthProvider` 呼び出しですでに `https` をスキームとして使用しており、これは App Links に必要です。上記の手順に従っていれば、コードを変更する必要はありません。
  </Info>

  詳細については、[Enable Android App Links Support](/ja/docs/get-started/applications/enable-android-app-links-support) のドキュメントと、Android の [Verify App Links](https://developer.android.com/training/app-links/verify-site-associations) ガイドを参照してください。
</Accordion>

<Accordion title="カスタム URL スキームを使用する">
  Android App Links を使用できない場合 (たとえば、対象の Android API バージョンが 23 未満の場合) は、代わりにカスタム URL スキームを設定できます。

  <Warning>
    カスタム URL スキームは、[クライアントなりすまし攻撃](https://datatracker.ietf.org/doc/html/rfc8252#section-8.6)を受ける可能性があるため、App Links よりも安全性が低くなります。可能な限り App Links を使用してください。
  </Warning>

  1. `app/build.gradle.kts` で `auth0Scheme` の manifest プレースホルダーを更新します。

  ```kotlin app/build.gradle.kts lines theme={null}
  android {
      defaultConfig {
          manifestPlaceholders += mapOf(
              "auth0Domain" to "@string/com_auth0_domain",
              "auth0Scheme" to "myapp" // 一意のカスタムスキームを使用
          )
      }
  }
  ```

  2. [Auth0 Dashboard](https://manage.auth0.com/#/applications) のアプリケーション設定で、**Allowed Callback URLs** と **Allowed Logout URLs** を更新し、カスタムスキームを使用するようにします。

  ```
  myapp://{yourDomain}/android/PACKAGE_NAME/callback
  ```

  3. `WebAuthProvider` を呼び出すときにカスタムスキームを渡します。

  ```kotlin MainActivity.kt lines theme={null}
  WebAuthProvider.login(auth0)
      .withScheme("myapp")
      .withScope("openid profile email offline_access")
      .start(this, callback)
  ```

  <Note>
    カスタムスキームには[小文字のみ使用できます](https://developer.android.com/guide/topics/manifest/data-element)。
  </Note>
</Accordion>

<Accordion title="本番環境へのデプロイ">
  ### App Store の準備

  * シームレスな認証のために Android App Links を設定する
  * 複数の Android バージョンと画面サイズでテストする
  * ネットワーク障害に備えて適切なエラーハンドリングを実装する
  * コード難読化を使用している場合は、Auth0 SDK 用の ProGuard ルールを追加する
  * 認証フローに関する Google Play Store のポリシーに従う

  ### セキュリティに関する考慮事項

  * 本番環境での認証情報の保存には `SecureCredentialsManager` を使用する
  * API セキュリティをさらに強化するために証明書ピンニングを実装する
  * 認証情報の保護を強化するために Android Keystore の使用を検討する
  * 機密性の高い操作では生体認証を有効にする
</Accordion>

<Accordion title="高度な Android 統合">
  ### 強化された認証情報セキュリティ

  認証情報へのアクセスに生体認証を実装します。

  ```kotlin AuthenticationManager.kt expandable lines theme={null}
  class AuthenticationManager(private val context: Context) {
      
      private val credentialsManager: SecureCredentialsManager
      
      init {
          val authentication = AuthenticationAPIClient(auth0)
          val storage = SharedPreferencesStorage(context)
          credentialsManager = SecureCredentialsManager(context, authentication, storage)
          
          // 生体認証を有効にする
          credentialsManager.requireAuthentication(
              context as FragmentActivity,
              REQUEST_CODE_BIOMETRIC,
              "Biometric Authentication",
              "Please authenticate to access your account"
          )
      }
      
      companion object {
          private const val REQUEST_CODE_BIOMETRIC = 321
      }
  }
  ```

  ### カスタムスコープとオーディエンス

  API に対して特定のスコープとオーディエンスをリクエストします。

  ```kotlin AuthenticationManager.kt expandable lines theme={null}
  fun login() {
      WebAuthProvider.login(auth0)
          .withScheme("https")
          .withScope("openid profile email offline_access read:posts")
          .withAudience("https://myapi.example.com")
          .withParameter("prompt", "login")
          .start(context as MainActivity, loginCallback)
  }
  ```

  ### ネットワーク設定

  ネットワークセキュリティと証明書ピンニングに対応します。

  ```xml app/src/main/res/xml/network_security_config.xml expandable lines theme={null}
  <?xml version="1.0" encoding="utf-8"?>
  <network-security-config>
      <domain-config>
          <domain includeSubdomains="true">your-auth0-domain.auth0.com</domain>
          <pin-set>
              <pin digest="SHA-256">AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</pin>
          </pin-set>
      </domain-config>
  </network-security-config>
  ```

  `AndroidManifest.xml` に追加します。

  ```xml theme={null}
  <application
      android:networkSecurityConfig="@xml/network_security_config"
      ... />
  ```
</Accordion>