Hitelesítés engedélyezése saját Android-alkalmazásban az Azure AD B2C használatával

Fontos

2025. május 1-jére az Azure AD B2C már nem lesz elérhető az új ügyfelek számára. További információ a GYIK-ben.

Ez a cikk bemutatja, hogyan vehet fel Azure Active Directory B2C(Azure AD B2C) hitelesítést saját Android-mobilalkalmazásába.

Ez a cikk az Azure AD B2C használatával történő hitelesítés konfigurálása androidos mintaalkalmazásban való konfigurálásával, a minta Android-alkalmazás saját Android-alkalmazással való helyettesítésével. Miután elvégezte a cikkben leírt utasításokat, az alkalmazás elfogadja a bejelentkezéseket az Azure AD B2C-vel.

Előfeltételek

Tekintse át az előfeltételeket és az integrációs utasításokat az Azure AD B2C használatával a hitelesítés konfigurálása androidos mintaalkalmazásban.

Android-alkalmazásprojekt létrehozása

Ha még nem rendelkezik Android-alkalmazással, állítson be egy új projektet az alábbi lépéssel:

Az Android Studióban válassza az Új Android Studio-projekt indítása lehetőséget.
Válassza az Alapszintű tevékenység lehetőséget, majd a Tovább gombot.
Adjon nevet az alkalmazásnak.
Mentse a csomag nevét. Ezt később az Azure Portalon fogja megadni.
Módosítsa a nyelvet a Kotlinról Java-ra.
Állítsa a minimális API-szintet 19-es vagy újabb API-ra, majd válassza a Befejezés lehetőséget.
A projektnézetben válassza a Projekt lehetőséget a legördülő listában a forrás- és nem forrásprojektfájlok megjelenítéséhez, nyissa meg az app/build.gradle fájlt, majd állítsa a targetSdkVersion 28-ra.

1. lépés: A függőségek telepítése

Az Android Studio projektablakában lépjen az alkalmazás>build.gradle elemére, és adja hozzá a következőket:

apply plugin: 'com.android.application'

allprojects {
    repositories {
    mavenCentral()
    google()
    mavenLocal()
    maven {
        url 'https://pkgs.dev.azure.com/MicrosoftDeviceSDK/DuoSDK-Public/_packaging/Duo-SDK-Feed/maven/v1'
    }
    maven {
        name "vsts-maven-adal-android"
        url "https://identitydivision.pkgs.visualstudio.com/_packaging/AndroidADAL/maven/v1"
        credentials {
            username System.getenv("ENV_VSTS_MVN_ANDROIDADAL_USERNAME") != null ? System.getenv("ENV_VSTS_MVN_ANDROIDADAL_USERNAME") : project.findProperty("vstsUsername")
            password System.getenv("ENV_VSTS_MVN_ANDROIDADAL_ACCESSTOKEN") != null ? System.getenv("ENV_VSTS_MVN_ANDROIDADAL_ACCESSTOKEN") : project.findProperty("vstsMavenAccessToken")
        }
    }
    jcenter()
    }
}
dependencies{
    implementation 'com.microsoft.identity.client:msal:2.+'
    }
packagingOptions{
    exclude("META-INF/jersey-module-version")
}

2. lépés: A hitelesítési összetevők hozzáadása

A mintakód a következő összetevőkből áll. Vegye fel ezeket az összetevőket a minta Android-alkalmazásból a saját alkalmazásába.

Összetevő	Típus	Forrás	Leírás
B2CUser	Osztály	Kotlin Jáva	B2C-felhasználót jelöl. Ez az osztály lehetővé teszi, hogy a felhasználók több szabályzattal jelentkezzenek be.
B2CModeFragment	Töredékosztály	Kotlin Jáva	A töredék a bejelentkezés moduláris részét jelöli az Azure AD B2C felhasználói felülettel a fő tevékenységen belül. Ez a töredék tartalmazza a legtöbb hitelesítési kódot.
fragment_b2c_mode.xml	Töredék elrendezése	Kotlin Jáva	Meghatározza a B2CModeFragment töredék összetevő felhasználói felületének struktúráját.
B2CConfiguráció	Osztály	Kotlin Jáva	Egy konfigurációs fájl információkat tartalmaz az Azure AD B2C-identitásszolgáltatóról. A mobilalkalmazás ezeket az információkat felhasználva megbízhatósági kapcsolatot létesít az Azure AD B2C-vel, bejelentkezteti a felhasználókat, ki- és bejelentkezik, jogkivonatokat szerez be és érvényesít. További konfigurációs beállításokért tekintse meg a auth_config_b2c.json fájlt.
auth_config_b2c.json	JSON-fájl	Kotlin Jáva	Egy konfigurációs fájl információkat tartalmaz az Azure AD B2C-identitásszolgáltatóról. A mobilalkalmazás ezeket az információkat felhasználva megbízhatósági kapcsolatot létesít az Azure AD B2C-vel, bejelentkezteti a felhasználókat, ki- és bejelentkezik, jogkivonatokat szerez be és érvényesít. További konfigurációs beállításokért tekintse meg a B2CConfiguration osztályt.

3. lépés: Az Android-alkalmazás konfigurálása

A hitelesítési összetevők hozzáadása után konfigurálja az Android-alkalmazást az Azure AD B2C-beállításaival. Az Azure AD B2C identitásszolgáltatói beállításai a auth_config_b2c.json fájlban és a B2CConfiguration osztályban vannak konfigurálva.

Útmutatásért tekintse meg a minta mobilalkalmazás konfigurálását ismertető témakört.

4. lépés: Az átirányítási URI beállítása

Konfigurálja, hogy az alkalmazás hol figyeli az Azure AD B2C-jogkivonat válaszát.

Hozzon létre egy új fejlesztési aláírás kivonatát. Ez minden fejlesztési környezetben megváltozik.

Windows esetén:

keytool -exportcert -alias androiddebugkey -keystore %HOMEPATH%\.android\debug.keystore | openssl sha1 -binary | openssl base64

iOS esetén:

keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore | openssl sha1 -binary | openssl base64

Éles környezetben használja a következő parancsot:

keytool -exportcert -alias SIGNATURE_ALIAS -keystore PATH_TO_KEYSTORE | openssl sha1 -binary | openssl base64

Az alkalmazások aláírásával kapcsolatos további segítségért tekintse meg az Android-alkalmazás aláírása című témakört.

Válassza ki az alkalmazás>, majd adja hozzá a következő > tevékenységet az alkalmazás törzséhez:

<!--Intent filter to capture System Browser or Authenticator calling back to our app after sign-in-->
<activity
    android:name="com.microsoft.identity.client.BrowserTabActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="msauth"
            android:host="Package_Name"
            android:path="/Signature_Hash" />
    </intent-filter>
</activity>

Cserélje le Signature_Hash a létrehozott kivonatra.
Cserélje le Package_Name az Android-csomag nevére.

Ha frissíteni szeretné a mobilalkalmazás-regisztrációt az alkalmazásátirányítási URI-val, tegye a következőket:

Jelentkezzen be az Azure Portalra.
Ha több bérlőhöz is hozzáfér, a felső menü Beállítások ikonját választva válthat az Azure AD B2C-bérlőre a Címtárak + előfizetések menüből.
Keresse meg és válassza ki az Azure AD B2C-t.
Válassza ki a Alkalmazásregisztrációk, majd válassza ki a 2.3. lépésben regisztrált alkalmazást: Regisztrálja a mobilalkalmazást.
Válassza a Hitelesítés lehetőséget.
Az Android alatt válassza az URI hozzáadása lehetőséget.
Adja meg a csomag nevét és az aláírás kivonatát.
Válassza a Mentés lehetőséget.

Az átirányítási URI-nak és a BrowserTabActivity tevékenységnek az alábbi mintához hasonlóan kell kinéznie:

Kotlin
Jáva

A minta Android átirányítási URL-címe a következőképpen néz ki:

msauth://com.azuresamples.msalandroidkotlinapp/1wIqXSqBj7w%2Bh11ZifsnqwgyKrY%3D

A szándékszűrő ugyanazt a mintát használja, mint az alábbi XML-kódrészletben:

<activity android:name="com.microsoft.identity.client.BrowserTabActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:host="com.azuresamples.msalandroidkotlinapp"
            android:path="/1wIqXSqBj7w+h11ZifsnqwgyKrY="
            android:scheme="msauth" />
    </intent-filter>
</activity>

A minta Android átirányítási URL-címe a következőképpen néz ki:

msauth://com.azuresamples.msalandroidapp/1wIqXSqBj7w%2Bh11ZifsnqwgyKrY%3D

A szándékszűrő ugyanazt a mintát használja, mint az alábbi XML-kódrészletben:

<activity android:name="com.microsoft.identity.client.BrowserTabActivity">
<intent-filter>
    <action android:name="android.intent.action.VIEW" />

    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />

    <data
        android:host="com.azuresamples.msalandroidapp"
        android:path="/1wIqXSqBj7w+h11ZifsnqwgyKrY="
        android:scheme="msauth" />
</intent-filter>
</activity>

5. lépés: A kód építőelemeinek testreszabása

Ez a szakasz az Android-alkalmazás hitelesítését engedélyező kód építőelemeit ismerteti. Az alábbi táblázat a B2CModeFragment metódusokat és a kód testreszabását sorolja fel.

5.1. lépés: Nyilvános ügyfélalkalmazás példányosítása

A nyilvános ügyfélalkalmazások nem megbízhatók az alkalmazás titkos kulcsának biztonságos megőrzéséhez, és nem rendelkeznek titkos ügyfélkódokkal. Az onCreate-ban vagy az onCreateView-ban példányosíthatja az MSAL-t a többfiókos nyilvános ügyfélalkalmazás-objektum használatával.

Az MultipleAccountPublicClientApplication osztály olyan MSAL-alapú alkalmazások létrehozására szolgál, amelyek lehetővé teszik több fiók egyidejű bejelentkezését. Az osztály több Azure AD B2C felhasználói folyamattal vagy egyéni szabályzattal engedélyezi a bejelentkezést. A felhasználók például egy regisztrációs vagy bejelentkezési felhasználói folyamattal jelentkeznek be, majd később egy szerkesztési profil felhasználói folyamatát futtatják.

Az alábbi kódrészlet bemutatja, hogyan kezdeményezheti az MSAL-kódtárat a auth_config_b2c.json konfigurációs JSON-fájllal.

Kotlin
Jáva

PublicClientApplication.createMultipleAccountPublicClientApplication(context!!,
    R.raw.auth_config_b2c,
    object : IMultipleAccountApplicationCreatedListener {
        override fun onCreated(application: IMultipleAccountPublicClientApplication) {
            // Set the MultipleAccountPublicClientApplication to the class member b2cApp
            b2cApp = application
            // Load the account (if there is any)
            loadAccounts()
        }

        override fun onError(exception: MsalException) {
            // Error handling
            displayError(exception)
        }
    })

PublicClientApplication.createMultipleAccountPublicClientApplication(getContext(),
    R.raw.auth_config_b2c,
    new IPublicClientApplication.IMultipleAccountApplicationCreatedListener() {
        @Override
        public void onCreated(IMultipleAccountPublicClientApplication application) {
            // Set the MultipleAccountPublicClientApplication to the class member b2cApp
            b2cApp = application;

            // Load the account (if there is any)
            loadAccounts();
        }

        @Override
        public void onError(MsalException exception) {
            // Error handling
            displayError(exception);
        }
    });

5.2. lépés: Fiókok betöltése

Amikor az alkalmazás előtérbe kerül, az alkalmazás betölti a meglévő fiókot annak megállapításához, hogy a felhasználók bejelentkezve vannak-e. Ezzel a módszerrel frissítheti a felhasználói felületet a hitelesítési állapottal. Engedélyezheti vagy letilthatja például a kijelentkezés gombot.

Az alábbi kódrészlet bemutatja, hogyan töltheti be a fiókokat.

Kotlin
Jáva

private fun loadAccounts() {
    if (b2cApp == null) {
        return
    }
    b2cApp!!.getAccounts(object : LoadAccountsCallback {
        override fun onTaskCompleted(result: List<IAccount>) {
            users = B2CUser.getB2CUsersFromAccountList(result)
            updateUI(users)
        }
    
        override fun onError(exception: MsalException) {
            displayError(exception)
        }
    })
    }

private void loadAccounts() {
    if (b2cApp == null) {
        return;
    }

    b2cApp.getAccounts(new IPublicClientApplication.LoadAccountsCallback() {
        @Override
        public void onTaskCompleted(final List<IAccount> result) {
            users = B2CUser.getB2CUsersFromAccountList(result);
            updateUI(users);
        }

        @Override
        public void onError(MsalException exception) {
            displayError(exception);
        }
    });
}

5.3. lépés: Interaktív engedélyezési kérelem indítása

Az interaktív engedélyezési kérések olyan folyamatok, amelyekben a felhasználók a regisztrációra vagy a bejelentkezésre kérik őket. A initializeUI metódus konfigurálja a kattintási runUserFlowButton eseményt. Amikor a felhasználók a Felhasználói folyamat futtatása gombra kattintanak, az alkalmazás az Azure AD B2C-be viszi őket a bejelentkezési folyamat befejezéséhez.

A runUserFlowButton.setOnClickListener metódus előkészíti az objektumot az AcquireTokenParameters engedélyezési kérelemre vonatkozó releváns adatokkal. A acquireToken metódus ezután felszólítja a felhasználókat a regisztrációs vagy bejelentkezési folyamat befejezésére.

Az alábbi kódrészlet bemutatja, hogyan indíthatja el az interaktív engedélyezési kérelmet:

Kotlin
Jáva

val parameters = AcquireTokenParameters.Builder()
        .startAuthorizationFromActivity(activity)
        .fromAuthority(getAuthorityFromPolicyName(policy_list.getSelectedItem().toString()))
        .withScopes(B2CConfiguration.scopes)
        .withPrompt(Prompt.LOGIN)
        .withCallback(authInteractiveCallback)
        .build()

b2cApp!!.acquireToken(parameters)

AcquireTokenParameters parameters = new AcquireTokenParameters.Builder()
        .startAuthorizationFromActivity(getActivity())
        .fromAuthority(B2CConfiguration.getAuthorityFromPolicyName(policyListSpinner.getSelectedItem().toString()))
        .withScopes(B2CConfiguration.getScopes())
        .withPrompt(Prompt.LOGIN)
        .withCallback(getAuthInteractiveCallback())
        .build();

b2cApp.acquireToken(parameters);

5.4. lépés: Interaktív engedélyezési kérelem visszahívása

Miután a felhasználók befejezték az engedélyezési folyamatot, akár sikeresen, akár sikertelenül, a visszahívási metódus visszaadja az getAuthInteractiveCallback() eredményt.

A visszahívási módszer átadja az AuthenticationResult objektumot, vagy egy hibaüzenetet az MsalException objektumban. Ezzel a módszerrel:

A bejelentkezés befejezése után frissítse a mobilalkalmazás felhasználói felületét az adatokkal.
Töltse be újra a fiókobjektumot.
Webes API-szolgáltatás meghívása hozzáférési jogkivonattal.
Hitelesítési hibák kezelése.

Az alábbi kódrészlet bemutatja az interaktív hitelesítési visszahívás használatát.

Kotlin
Jáva

private val authInteractiveCallback: AuthenticationCallback
    private get() = object : AuthenticationCallback {
        override fun onSuccess(authenticationResult: IAuthenticationResult) {
            /* Successfully got a token, use it to call a protected resource; web API  */
            Log.d(TAG, "Successfully authenticated")

            /* display result info */
            displayResult(authenticationResult)

            /* Reload account asynchronously to get the up-to-date list. */
            loadAccounts()
        }

        override fun onError(exception: MsalException) {
            val B2C_PASSWORD_CHANGE = "AADB2C90118"
            if (exception.message!!.contains(B2C_PASSWORD_CHANGE)) {
                txt_log!!.text = """
                    Users click the 'Forgot Password' link in a sign-up or sign-in user flow.
                    Your application needs to handle this error code by running a specific user flow that resets the password.
                    """.trimIndent()
                return
            }

            /* Failed to acquireToken */Log.d(TAG, "Authentication failed: $exception")
            displayError(exception)
            if (exception is MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception is MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            }
        }

        override fun onCancel() {
            /* User canceled the authentication */
            Log.d(TAG, "User cancelled login.")
        }
    }

private AuthenticationCallback getAuthInteractiveCallback() {
    return new AuthenticationCallback() {

        @Override
        public void onSuccess(IAuthenticationResult authenticationResult) {
            /* Successfully got a token, use it to call a protected resource - MSGraph */
            Log.d(TAG, "Successfully authenticated");

            /* display result info */
            displayResult(authenticationResult);

            /* Reload account asynchronously to get the up-to-date list. */
            loadAccounts();
        }

        @Override
        public void onError(MsalException exception) {
            final String B2C_PASSWORD_CHANGE = "AADB2C90118";
            if (exception.getMessage().contains(B2C_PASSWORD_CHANGE)) {
                logTextView.setText("Users click the 'Forgot Password' link in a sign-up or sign-in user flow.\n" +
                        "Your application needs to handle this error code by running a specific user flow that resets the password.");
                return;
            }

            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: " + exception.toString());
            displayError(exception);

            if (exception instanceof MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            }
        }

        @Override
        public void onCancel() {
            /* User canceled the authentication */
            Log.d(TAG, "User cancelled login.");
        }
    };
}

6. lépés: Webes API meghívása

Jogkivonatalapú engedélyezési webes API meghívásához az alkalmazásnak érvényes hozzáférési jogkivonattal kell rendelkeznie. Az alkalmazás a következőket végzi el:

A webes API-végponthoz szükséges engedélyekkel (hatókörökkel) rendelkező hozzáférési jogkivonatot szerez be.
A http-kérelem engedélyezési fejlécében a következő formátumban adja át a hozzáférési jogkivonatot tulajdonosi jogkivonatként:

Authorization: Bearer <access-token>

Amikor a felhasználók interaktívan jelentkeznek be, az alkalmazás egy hozzáférési jogkivonatot kap a visszahívási getAuthInteractiveCallback módszerben. Egymást követő webes API-hívásokhoz használja az ebben a szakaszban ismertetett csendes jogkivonat-lekérési eljárást.

A webes API meghívása előtt hívja meg a acquireTokenSilentAsync metódust a webes API-végpont megfelelő hatóköreivel. Az MSAL-kódtár a következőket végzi el:

Megpróbál lekérni egy hozzáférési jogkivonatot a kért hatókörökkel a jogkivonat-gyorsítótárból. Ha a jogkivonat jelen van, a jogkivonat vissza lesz adva.
Ha a jogkivonat nem található meg a jogkivonat gyorsítótárában, az MSAL megpróbálja a frissítési jogkivonatát használni egy új jogkivonat beszerzéséhez.
Ha a frissítési jogkivonat nem létezik vagy lejárt, a rendszer kivételt ad vissza. Javasoljuk, hogy kérje meg a felhasználót, hogy jelentkezzen be interaktívan.

A következő kódrészlet bemutatja, hogyan szerezhet be hozzáférési jogkivonatot:

Kotlin
Jáva

A acquireTokenSilentButton gombkattintásos esemény egy hozzáférési jogkivonatot szerez be a megadott hatókörökkel.

btn_acquireTokenSilently.setOnClickListener(View.OnClickListener {
    if (b2cApp == null) {
        return@OnClickListener
    }
    val selectedUser = users!![user_list.getSelectedItemPosition()]
    selectedUser.acquireTokenSilentAsync(b2cApp!!,
            policy_list.getSelectedItem().toString(),
            B2CConfiguration.scopes,
            authSilentCallback)
})

A authSilentCallback visszahívási módszer egy hozzáférési jogkivonatot ad vissza, és meghív egy webes API-t:

private val authSilentCallback: SilentAuthenticationCallback
    private get() = object : SilentAuthenticationCallback {
        override fun onSuccess(authenticationResult: IAuthenticationResult) {
            Log.d(TAG, "Successfully authenticated")

            /* Call your web API here*/
            callWebAPI(authenticationResult)
        }

        override fun onError(exception: MsalException) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: $exception")
            displayError(exception)
            if (exception is MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception is MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            } else if (exception is MsalUiRequiredException) {
                /* Tokens expired or no session, retry with interactive */
            }
        }
    }

Az alábbi példa bemutatja, hogyan hívhat meg védett webes API-t egy tulajdonosi jogkivonattal:

@Throws(java.lang.Exception::class)
private fun callWebAPI(authenticationResult: IAuthenticationResult) {
    val accessToken = authenticationResult.accessToken
    val thread = Thread {
        try {
            val url = URL("https://your-app-service.azurewebsites.net/helo")
            val conn = url.openConnection() as HttpsURLConnection
            conn.setRequestProperty("Accept", "application/json")
            
            // Set the bearer token
            conn.setRequestProperty("Authorization", "Bearer $accessToken")
            if (conn.responseCode == HttpURLConnection.HTTP_OK) {
                val br = BufferedReader(InputStreamReader(conn.inputStream))
                var strCurrentLine: String?
                while (br.readLine().also { strCurrentLine = it } != null) {
                    Log.d(TAG, strCurrentLine)
                }
            }
            conn.disconnect()
        } catch (e: IOException) {
            e.printStackTrace()
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
    thread.start()
}

A acquireTokenSilentButton gombkattintásos esemény egy hozzáférési jogkivonatot szerez be a megadott hatókörökkel.

acquireTokenSilentButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        if (b2cApp == null) {
            return;
        }

        final B2CUser selectedUser = users.get(b2cUserList.getSelectedItemPosition());
        selectedUser.acquireTokenSilentAsync(b2cApp,
                policyListSpinner.getSelectedItem().toString(),
                B2CConfiguration.getScopes(),
                getAuthSilentCallback());
    }
});

A authSilentCallback visszahívási módszer egy hozzáférési jogkivonatot ad vissza, és meghív egy webes API-t:

private SilentAuthenticationCallback getAuthSilentCallback() {
    return new SilentAuthenticationCallback() {

        @Override
        public void onSuccess(IAuthenticationResult authenticationResult) {
            Log.d(TAG, "Successfully authenticated");

            /* Call your web API here*/
            callWebAPI(authenticationResult);
        }

        @Override
        public void onError(MsalException exception) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: " + exception.toString());
            displayError(exception);

            if (exception instanceof MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            } else if (exception instanceof MsalUiRequiredException) {
                /* Tokens expired or no session, retry with interactive */
            }
        }
    };
}

Az alábbi példa bemutatja, hogyan hívhat meg védett webes API-t egy tulajdonosi jogkivonattal:

private void callWebAPI(IAuthenticationResult authenticationResult) throws Exception {
    final String accessToken = authenticationResult.getAccessToken();
    
    
    Thread thread = new Thread(new Runnable() {
    
        @Override
        public void run() {
            try {
                URL url = new URL("https://your-app-service.azurewebsites.net/helo");
                HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
                conn.setRequestProperty("Accept", "application/json");
                
                // Set the bearer token
                conn.setRequestProperty("Authorization", "Bearer " +  accessToken);
    
                if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
                    BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                    String strCurrentLine;
                    while ((strCurrentLine = br.readLine()) != null) {
                        Log.d(TAG, strCurrentLine);
                    }
                }
                conn.disconnect();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    
    thread.start();
    
    }

Hálózati műveletek végrehajtásához szükséges engedély hozzáadása

Ha hálózati műveleteket szeretne végrehajtani az alkalmazásban, adja hozzá a következő engedélyt a jegyzékhez. További információ: Csatlakozás a hálózathoz.

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

Következő lépések

Az alábbiak végrehajtásának módját ismerheti meg:

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-06-23