> ## 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
  ```

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

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

  AI アシスタントは、Auth0 アプリケーションの作成、資格情報の取得、Auth0 Android SDK 依存関係の追加、manifest placeholders の設定、ログイン/ログアウト フローの実装を自動的に行います。[agent skills の完全なドキュメント →](/docs/ja-jp/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:4.0.0")
    }
    ```

    **アプリレベルの`build.gradle.kts`にmanifest placeholdersを追加します。**

    ```kotlin app/build.gradle.kts lines theme={null}
    android {
        defaultConfig {
            // これらのmanifest placeholdersを追加する
            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 App を設定する" 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. **アプリケーション** > **アプリケーション** > **アプリケーションを作成** をクリックします
    3. ポップアップでアプリ名を入力し、アプリの種類として `Native` を選択して **Create** をクリックします
    4. アプリケーションの詳細ページで **設定** タブに切り替えます
    5. `strings.xml` ファイル内の `{yourDomain}` と `YOUR_AUTH0_CLIENT_ID` を、ダッシュボードの **Domain** と **Client ID** の値に置き換えます

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

  <Step title="Auth0 SDK の初期化" stepNumber={4}>
    Auth0 と通信するため、Activity 内で 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と Domain を使って初期化されます。このインスタンスは、すべての認証処理で使用されます。
    </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>

    **Logout を実装:** 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の「今すぐ同期」を使用）
    ./gradlew clean build

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

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

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

    1. アプリが起動し、「Log In」ボタンと盾のアイコンが表示される
    2. 「Log In」をタップ → Chrome Custom Tab が開く → ログインを完了
    3. 自動的にアプリに戻る
    4. 成功!!

    <Warning>
      Android では、複数のブラウザーがインストールされている場合、ブラウザーの選択ダイアログが表示されます。Auth0認証では、Chrome Custom Tabs が最適なユーザーエクスペリエンスを提供します。
    </Warning>
  </Step>
</Steps>

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

  これで、Android デバイスまたはエミュレーターで、完全に機能する Auth0 login を利用できるようになっているはずです。このアプリは、安全な認証のために 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. Domain の形式に誤りがないことを確認します (`https://` は含めないでください)

  ### dependencies に関連するビルドエラー

  **修正方法:**

  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` スキームのコールバックを使用します。これはカスタム URL スキームよりも安全です。カスタム URL スキームは [クライアントのなりすまし攻撃](https://datatracker.ietf.org/doc/html/rfc8252#section-8.6) の対象になる可能性があります。
  </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. **設定** ページの一番下までスクロールし、**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>
    この Quickstart では、manifest placeholders と `WebAuthProvider` 呼び出しですでに `https` をスキームとして使用しており、これは App Links に必要です。上記の手順に従っていれば、コードを変更する必要はありません。
  </Info>

  詳しくは、[Enable Android App Links Support](/docs/ja-jp/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` マニフェスト プレースホルダーを更新します。

  ```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
      }
  }
  ```

  ### カスタム スコープと audience

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

  ```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>