App Center Distribute – Android alkalmazáson belüli frissítések

2025-05-05

Fontos

A Visual Studio App Center 2025. március 31-én megszűnt, kivéve az Elemzési és diagnosztikai funkciókat, amelyek 2026. június 30-ig továbbra is támogatottak lesznek. Tudj meg többet.

Az App Center Distribute lehetővé teszi a felhasználóknak az alkalmazás új verziójának telepítését az App Centeren keresztüli terjesztésekor. Ha elérhető az alkalmazás új verziója, az SDK egy frissítési párbeszédpanelt jelenít meg a felhasználóknak az új verzió letöltéséhez vagy elhalasztásához. Miután a frissítés mellett döntöttek, az SDK megkezdi az alkalmazás frissítését.

Figyelmeztetés

A Google Play rosszindulatú viselkedésnek tekinti az alkalmazáson belüli frissítési kódot, még akkor is, ha futásidőben nem használják. Használja az Elosztott SDK egyik változatát az ebben a szakaszban leírtak szerint, vagy távolítsa el teljesen az alkalmazáson belüli frissítési kódot tartalmazó Elosztott SDK-t, mielőtt elküldené az alkalmazást a Google Play-be. Ennek elmulasztása az alkalmazás nem megfelelőségét és a Google Play-ből való eltávolítását eredményezheti.

Megjegyzés:

Ha automatizált felhasználói felületi teszteket futtat, az alkalmazáson belüli engedélyezett frissítések letiltják az automatikus felhasználói felületi teszteket, miközben megpróbálnak hitelesítést végezni az App Center háttérrendszerén. Javasoljuk, hogy ne engedélyezze az App Center Distributet a felhasználói felületi tesztekhez.

Alkalmazáson belüli frissítések hozzáadása az alkalmazáshoz

Ha még nem állította be és indította el az SDK-t az alkalmazásban, kövesse az Első lépések szakaszt.

1. Az App Center Distribute modul hozzáadása

Az App Center SDK moduláris megközelítéssel lett kialakítva – a fejlesztőknek csak az őket érdeklő szolgáltatások moduljait kell integrálniuk.

Nyissa meg a projekt alkalmazásszintű build.gradle fájlját (app/build.gradle), és adja hozzá a következő sorokat.apply plugin
```
dependencies {
   def appCenterSdkVersion = '5.0.6'
   implementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
}
```
Megjegyzés:

Ha az Android Gradle beépülő modul verziója kisebb, mint 3.0.0, az implementációtcompile-ra kell cserélnie.
Mentse a build.gradle fájlt, és mindenképpen aktiváljon Gradle-szinkronizálást az Android Studióban.
A DownloadManager a frissítések letöltésére szolgál. Az App Center SDK a biztonság javítása érdekében kényszeríti a TLS 1.2-t.

2. Az App Center distribute indítása

Az App Center használatához jelentkezzen be a használni kívánt modul(ok)ba. Alapértelmezés szerint nem indulnak el modulok, és az SDK indításakor mindegyiknek explicit módon kell meghívnia őket.

Adja hozzá az Distribute osztályt a metódushoz az AppCenter.start() App Center Distribute szolgáltatás elindításához.

AppCenter.start(getApplication(), "{Your App Secret}", Distribute.class);

AppCenter.start(application, "{Your App Secret}", Distribute::class.java)

Győződjön meg arról, hogy a fenti kódmintában lecserélte a {Your App Secret} az alkalmazás titkos kulcsára. Az Android Studio automatikusan javasolja a szükséges importálási utasítást, miután hozzáad egy hivatkozást az Distribute osztályhoz a start() metódushoz, de ha hibaüzenet jelenik meg, hogy az osztálynevek nem ismerődnek fel, adja hozzá a következő sorokat a tevékenységosztály importálási utasításaihoz:

import com.microsoft.appcenter.AppCenter;
import com.microsoft.appcenter.distribute.Distribute;

import com.microsoft.appcenter.AppCenter
import com.microsoft.appcenter.distribute.Distribute

Megjegyzés:

Az Android 10-et vagy újabb verziót a háttérben futó indítási tevékenységek korlátozásai korlátozzák. Tekintse meg a háttérben futó tevékenységek indítására vonatkozó korlátozásokat ismertető cikket.

Megjegyzés:

Az Android 10 (Go edition) rendszeren futó alkalmazások nem kapják meg a SYSTEM_ALERT_WINDOW engedélyt. Kérjük, tekintse meg a cikket a Go-eszközökön használható SYSTEM_ALERT_WINDOW-ről.

Megjegyzés:

Az Android 11-től kezdve a ACTION_MANAGE_OVERLAY_PERMISSION intentek mindig a Beállítások főképernyőjére navigálnak, ahol a felhasználó engedélyezheti vagy visszavonhatja a SYSTEM_ALERT_WINDOW alkalmazások jogosultságait. Tekintse meg az Android 11 engedélyfrissítéseiről szóló cikket.

Google Play-verzió előkészítése

Nyissa meg a projekt alkalmazásszintű build.gradle fájlját (app/build.gradle).

Konfigurálja a build variánsokat termékváltozatok hozzáadásával.

android {
    flavorDimensions "distribute"
    productFlavors {
        appCenter {
            dimension "distribute"
        }
        googlePlay {
            dimension "distribute"
        }
    }
}

Módosítsa a függőségek blokkot, hogy a termék ízétől függően különböző függőségeket használjon fel:

dependencies {
    def appCenterSdkVersion = "5.0.6"
    appCenterImplementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
    googlePlayImplementation "com.microsoft.appcenter:appcenter-distribute-play:${appCenterSdkVersion}"
}

Mentse a build.gradle fájlt, és mindenképpen aktiváljon Gradle-szinkronizálást az Android Studióban.
A buildvariánst a Build > Select Build Variant legördülő menüben vagy a Build Variants (Változatok összeállítása ) menüben módosíthatja az eszköz ablaksávjában.

A buildvariánsok konfigurálásáról az Android dokumentációjában olvashat bővebben.

Privát terjesztési csoport használata

Alapértelmezés szerint az Distribute nyilvános terjesztési csoportot használ. Ha privát terjesztési csoportot szeretne használni, explicit módon kell beállítania az API-val setUpdateTrack .

Distribute.setUpdateTrack(UpdateTrack.PRIVATE);

Distribute.setUpdateTrack(UpdateTrack.PRIVATE)

Megjegyzés:

Az alapértelmezett érték a UpdateTrack.PUBLIC. Ez a metódus csak a AppCenter.start metódushívás előtt hívható meg. A frissítési nyomon követés módosításai nem maradnak meg az alkalmazásfolyamat újraindításakor, ezért ha a metódust nem hívják meg mindig a AppCenter.start hívás előtt, az alapértelmezés szerint nyilvános lesz.

Amikor az alkalmazás előtérben van (Distribute.setUpdateTrack(UpdateTrack.PRIVATE); és AppCenter.start után), megnyílik egy böngészőablak a felhasználó hitelesítéséhez. Minden későbbi frissítési ellenőrzés megkapja a legújabb kiadást a privát pályán.

Ha egy felhasználó a privát pályán van, az azt jelenti, hogy a sikeres hitelesítés után megkapja a legújabb kiadást minden olyan privát terjesztési csoporttól, amelynek tagja. Ha egy felhasználó nyilvános pályán van, az azt jelenti, hogy bármely nyilvános terjesztési csoporttól megkapja a legújabb kiadást.

A frissítés automatikus ellenőrzésének letiltása

Alapértelmezés szerint az SDK automatikusan ellenőrzi az új kiadásokat:

Az alkalmazás indításakor.
Amikor az alkalmazás előtérbe kerül a háttérbe kerülés után.
Az Elosztott modul engedélyezésekor, ha korábban le lett tiltva.

Ha manuálisan szeretné ellenőrizni az új kiadásokat, letilthatja a frissítés automatikus ellenőrzését. Ehhez hívja meg a következő metódust az SDK indítása előtt:

Distribute.disableAutomaticCheckForUpdate();

Distribute.disableAutomaticCheckForUpdate()

Megjegyzés:

Ezt a metódust a AppCenter.start metódushívás előtt kell meghívni.

Ezután használhatja a checkForUpdate következő szakaszban ismertetett API-t.

Frissítés manuális ellenőrzése

Distribute.checkForUpdate();

Distribute.checkForUpdate()

Ez egy kérést küld az App Centernek, és megjelenít egy frissítési párbeszédpanelt, ha új kiadás érhető el.

Megjegyzés:

A frissítési hívás manuális ellenőrzése akkor is működik, ha az automatikus frissítések engedélyezve vannak. Ha egy másik ellenőrzés már folyamatban van, a rendszer figyelmen kívül hagyja a manuális frissítés-ellenőrzést. A manuális frissítés-ellenőrzés nem lesz feldolgozva, ha a felhasználó elhalasztotta a frissítéseket (kivéve, ha a legújabb verzió kötelező frissítés).

Az alkalmazáson belüli frissítési párbeszédpanel testreszabása vagy honosítása

1. Szöveg testreszabása vagy honosítása

Ha módosítani vagy honosítani szeretné a frissítési párbeszédpanelen megjelenő szöveget, egyszerűen megadhat saját erőforrás-sztringeket. Tekintse meg az erőforrásfájl sztringfájljait. Használja ugyanazt a sztringnevet/kulcsot, és adja meg azt a honosított értéket, amelyet a saját alkalmazás-erőforrásfájlok párbeszédpaneljén megjeleníthet.

2. A frissítési párbeszédpanel testreszabása

A felület implementálásával testre szabhatja az alapértelmezett frissítési DistributeListener párbeszédpanel megjelenését. Az alábbi példában látható módon regisztrálnia kell a figyelőt a AppCenter.start hívása előtt.

Distribute.setListener(new MyDistributeListener());
AppCenter.start(...);

Distribute.setListener(MyDistributeListener())
AppCenter.start(...)

Íme egy példa a figyelő implementációjára, amely az SDK párbeszédpanelt egy egyénire cseréli:

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.net.Uri;

import com.microsoft.appcenter.distribute.Distribute;
import com.microsoft.appcenter.distribute.DistributeListener;
import com.microsoft.appcenter.distribute.ReleaseDetails;
import com.microsoft.appcenter.distribute.UpdateAction;

public class MyDistributeListener implements DistributeListener {

    @Override
    public boolean onReleaseAvailable(Activity activity, ReleaseDetails releaseDetails) {

        // Look at releaseDetails public methods to get version information, release notes text or release notes URL
        String versionName = releaseDetails.getShortVersion();
        int versionCode = releaseDetails.getVersion();
        String releaseNotes = releaseDetails.getReleaseNotes();
        Uri releaseNotesUrl = releaseDetails.getReleaseNotesUrl();

        // Build our own dialog title and message
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(activity);
        dialogBuilder.setTitle("Version " + versionName + " available!"); // you should use a string resource instead, this is just a simple example
        dialogBuilder.setMessage(releaseNotes);

        // Mimic default SDK buttons
        dialogBuilder.setPositiveButton(com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_download, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {

                // This method is used to tell the SDK what button was clicked
                Distribute.notifyUpdateAction(UpdateAction.UPDATE);
            }
        });

        // We can postpone the release only if the update isn't mandatory
        if (!releaseDetails.isMandatoryUpdate()) {
            dialogBuilder.setNegativeButton(com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_postpone, new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {

                    // This method is used to tell the SDK what button was clicked
                    Distribute.notifyUpdateAction(UpdateAction.POSTPONE);
                }
            });
        }
        dialogBuilder.setCancelable(false); // if it's cancelable you should map cancel to postpone, but only for optional updates
        dialogBuilder.create().show();

        // Return true if you're using your own dialog, false otherwise
        return true;
    }
    
    @Override
    public void onNoReleaseAvailable(Activity activity) {
        Toast.makeText(activity, activity.getString(R.string.no_updates_available), Toast.LENGTH_LONG).show();
    }
}

import android.app.Activity
import android.app.AlertDialog
import com.microsoft.appcenter.distribute.Distribute
import com.microsoft.appcenter.distribute.DistributeListener
import com.microsoft.appcenter.distribute.ReleaseDetails
import com.microsoft.appcenter.distribute.UpdateAction

class MyDistributeListener : DistributeListener {

    override fun onReleaseAvailable(activity: Activity, releaseDetails: ReleaseDetails): Boolean {

        // Look at releaseDetails public methods to get version information, release notes text or release notes URL
        val versionName = releaseDetails.shortVersion
        val versionCode = releaseDetails.version
        val releaseNotes = releaseDetails.releaseNotes
        val releaseNotesUrl = releaseDetails.releaseNotesUrl

        // Build our own dialog title and message
        val dialogBuilder = AlertDialog.Builder(activity)
        dialogBuilder.setTitle("Version $versionName available!") // you should use a string resource instead, this is just a simple example
        dialogBuilder.setMessage(releaseNotes)

        // Mimic default SDK buttons
        dialogBuilder.setPositiveButton(
            com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_download
        ) { dialog, which ->
            // This method is used to tell the SDK what button was clicked
            Distribute.notifyUpdateAction(UpdateAction.UPDATE)
        }

        // We can postpone the release only if the update isn't mandatory
        if (!releaseDetails.isMandatoryUpdate) {
            dialogBuilder.setNegativeButton(
                com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_postpone
            ) { dialog, which ->
                // This method is used to tell the SDK what button was clicked
                Distribute.notifyUpdateAction(UpdateAction.POSTPONE)
            }
        }
        dialogBuilder.setCancelable(false) // if it's cancelable you should map cancel to postpone, but only for optional updates
        dialogBuilder.create().show()

        // Return true if you're using your own dialog, false otherwise
        return true
    }

    override fun onNoReleaseAvailable(activity: Activity) {
        Toast.makeText(activity, activity.getString(R.string.no_updates_available), Toast.LENGTH_LONG).show()
    }
}

Ahogy a példában látható, hívnia kell vagy Distribute.notifyUpdateAction(UpdateAction.UPDATE);, vagy Distribute.notifyUpdateAction(UpdateAction.POSTPONE);, ha a figyelő visszatér true.

Ha nem hívja meg a notifyUpdateAction függvényt, a visszahívás minden tevékenységváltozáskor ismétlődik.

A figyelő ismét meghívható ugyanazzal a kiadással, ha a tevékenység megváltozik, mielőtt a felhasználói művelet értesítést kap az SDK-nak.

Ez a viselkedés a következő forgatókönyvek lefedéséhez szükséges:

Az alkalmazás a háttérbe kerül (például a HOME billentyű lenyomásával), majd egy másik tevékenységben folytatódik.
A tevékenységet egy másik lefedi anélkül, hogy elhagyná az alkalmazást (például rákattint néhány értesítésre).
Egyéb hasonló forgatókönyvek.

Ebben az esetben előfordulhat, hogy a párbeszédpanelt üzemeltető tevékenység felhasználói beavatkozás nélkül lecserélődik. Az SDK tehát ismét meghívja a figyelőt, hogy vissza lehessen állítani az egyéni párbeszédpanelt.

Azokban az esetekben, amikor az SDK frissítéseket keres, és nem találja a jelenleg használtnál újabb frissítéseket, a rendszer meghív egy onNoReleaseAvailable felületi DistributeListener visszahívást. Ez lehetővé teszi egyéni kód végrehajtását ilyen esetekben. A fenti példa bemutatja, hogyan jeleníthet meg felugró üzenetet, amikor nem található frissítés.

Az App Center Distribute engedélyezése vagy letiltása futtatókörnyezetben

Az App Center Distribute futásidőben engedélyezhető és letiltható. Ha letiltja, az SDK nem biztosít alkalmazáson belüli frissítési funkciókat, de továbbra is használhatja az Distribute szolgáltatást az App Center portálon.

Distribute.setEnabled(false);

Distribute.setEnabled(false)

Az App Center Distribute ismételt engedélyezéséhez használja ugyanazt az API-t, de adja át true paraméterként.

Distribute.setEnabled(true);

Distribute.setEnabled(true)

Az állapot megmarad az eszköz tárolójában az alkalmazásindítások során.

Ez az API aszinkron, erről az App Center Aszinkron API-k útmutatójában olvashat bővebben.

Megjegyzés:

Ezt a módszert csak akkor szabad használni, ha a Distribute már elindult.

Ellenőrizze, hogy az App Center Distribute engedélyezve van-e

Azt is ellenőrizheti, hogy az App Center Distribute engedélyezve van-e, vagy sem:

Distribute.isEnabled();

Distribute.isEnabled()

Ez az API aszinkron, erről az App Center Aszinkron API-k útmutatójában olvashat bővebben.

Megjegyzés:

Ezt a metódust csak akkor szabad használni, ha a Distribute már elindult. Mindig visszaad false a kezdés előtt.

Alkalmazáson belüli frissítések engedélyezése a buildek hibakereséséhez

Az App Center alapértelmezés szerint csak kiadási buildekhez engedélyezi az alkalmazáson belüli frissítéseket.

Ha engedélyezni szeretné az alkalmazáson belüli frissítéseket a hibakeresési buildekben, hívja meg a következő metódust a következő előtt AppCenter.start:

Distribute.setEnabledForDebuggableBuild(true);

Distribute.setEnabledForDebuggableBuild(true)

Megjegyzés:

Ez a módszer csak a hibakeresési buildekre van hatással, és nincs hatással a kiadási buildekre. A hibakeresési build azt jelenti, hogy a android:debuggable kapcsoló true értékre van állítva (amit általában a gradle előre definiált hibakeresési build-variánsai automatikusan beállítanak). Ellenkező esetben ez egy kiadási build.

Hogyan működnek az alkalmazáson belüli frissítések?

Megjegyzés:

Az alkalmazáson belüli frissítések működéséhez le kell tölteni egy alkalmazás buildet a hivatkozásról. Ide-ről vagy manuálisan történő telepítés esetén nem működik.

Az alkalmazáson belüli frissítési funkció a következőképpen működik:

Ez a funkció csak az App Center Distribute szolgáltatással elosztott RELEASE buildekkel működik (alapértelmezés szerint).
Az SDK integrálása, az alkalmazás kiadási verziójának létrehozása és az App Centerbe való feltöltés után a terjesztési csoport felhasználói e-mailben értesítést kapnak az új kiadásról.
Amikor minden felhasználó megnyitja a hivatkozást az e-mailben, az alkalmazás telepítve lesz az eszközén. Fontos, hogy az e-mail-hivatkozást használják a telepítéshez – nem támogatjuk az oldalbetöltést. Amikor letölt egy alkalmazást a hivatkozásról, az SDK fontos információkat ment a cookie-kból, hogy később ellenőrizze a frissítéseket, különben az SDK nem rendelkezik ezekkel a kulcsfontosságú információkkal.
Ha az alkalmazás privátra állítja a pályát, megnyílik egy böngésző, amely hitelesíti a felhasználót, és engedélyezi az alkalmazáson belüli frissítéseket. A böngésző nem nyílik meg újra, amíg a hitelesítési adatok érvényesek maradnak, még akkor sem, ha később visszaáll a nyilvános pályára, és visszaáll a privátra. Ha a böngészőhitelesítés sikeres, a rendszer automatikusan visszairányítja a felhasználót az alkalmazásba. Ha a pálya nyilvános (ez az alapértelmezett), a következő lépés közvetlenül történik.
Az alkalmazás új kiadása az alkalmazáson belüli frissítési párbeszédpanelt jeleníti meg, amely arra kéri a felhasználókat, hogy frissítsék az alkalmazást, ha az a következő:
- magasabb versionCode érték vagy
- az versionCode egyenlő értéke, de a versionName más értéke.

Jótanács

Ha másodszor is feltölti ugyanazt az APK-t, a párbeszédpanel NEM jelenik meg, mivel a verziók megegyeznek.

Hogyan tesztelhetem az alkalmazáson belüli frissítéseket?

Az alkalmazáson belüli frissítések teszteléséhez fel kell töltenie a kiadási buildeket (amelyek az App Center SDK Distribute modulját használják) az App Center Portálra, és minden alkalommal növelni kell a verziószámokat.

Ha még nem tette meg, hozza létre az alkalmazást az App Center portálon.
Hozzon létre egy új terjesztési csoportot, és nevezze el, hogy felismerje, hogy az alkalmazáson belüli frissítési funkció tesztelésére szolgál.
Adja hozzá magát (vagy az összes olyan felhasználót, akit fel szeretne venni az alkalmazáson belüli frissítési funkció tesztjéhez). Ehhez használjon egy új vagy eldobható e-mail-címet, amelyet az apphoz nem használtak az App Centerben. Ez biztosítja, hogy a tapasztalat közel legyen a valódi tesztelők élményéhez.
Hozzon létre egy új buildet az alkalmazásból, amely tartalmazza az App Center Distributet , és tartalmazza a fent leírt beállítási logikát. Ha a csoport privát, ne felejtse el beállítani a privát alkalmazáson belüli frissítési pályát, mielőtt elkezdené használni a setUpdateTrack API-t.
Kattintson az Új kiadás terjesztése gombra a portálon, és töltse fel az alkalmazás buildet.
Miután a feltöltés befejeződött, kattintson a Tovább gombra, és válassza ki azt a terjesztési csoportot , amelyet az alkalmazásterjesztés célhelyeként hozott létre.
Tekintse át a terjesztést, és ossza el a buildet az alkalmazáson belüli tesztelési csoportnak.
A csoport tagjai meghívást kapnak az alkalmazás tesztelőinek. Miután elfogadták a meghívást, letölthetik az alkalmazást az App Center Portálról a mobileszközükről. Miután telepítették az alkalmazáson belüli frissítéseket, készen áll az alkalmazáson belüli frissítések tesztelésére.
Emeld meg az alkalmazás verzióját versionCode.
Készítse el az alkalmazás kiadási verzióját, és töltsön fel egy új buildet az alkalmazásból, ahogyan az előző lépésben tette, és ossza el a korábban létrehozott terjesztési csoportnak . A terjesztési csoport tagjai az alkalmazás következő indításakor új verziót fognak kérni.

Jótanács

Tekintse meg az App Center Distribute használatával kapcsolatos információkat a terjesztési csoportokkal kapcsolatos részletesebb információkért. Bár az App Center Distribute használatával kód hozzáadása nélkül terjesztheti az alkalmazás új verzióját, az App Center Distribute alkalmazáskódhoz való hozzáadása zökkenőmentesebb felhasználói élményt eredményez a tesztelők és a felhasználók számára az alkalmazáson belüli frissítés során.

Megosztás a következőn keresztül:

App Center Distribute – Android alkalmazáson belüli frissítések

Alkalmazáson belüli frissítések hozzáadása az alkalmazáshoz

1. Az App Center Distribute modul hozzáadása

2. Az App Center distribute indítása

Google Play-verzió előkészítése

Privát terjesztési csoport használata

A frissítés automatikus ellenőrzésének letiltása

Frissítés manuális ellenőrzése

Az alkalmazáson belüli frissítési párbeszédpanel testreszabása vagy honosítása

1. Szöveg testreszabása vagy honosítása

2. A frissítési párbeszédpanel testreszabása

Az App Center Distribute engedélyezése vagy letiltása futtatókörnyezetben

Ellenőrizze, hogy az App Center Distribute engedélyezve van-e

Alkalmazáson belüli frissítések engedélyezése a buildek hibakereséséhez

Hogyan működnek az alkalmazáson belüli frissítések?

Hogyan tesztelhetem az alkalmazáson belüli frissítéseket?

Visszajelzés

További források