Tartalom
- Mik az widget-ek az Android-hoz?
- Valóban szükségem van-e a projektem egy alkalmazás widgetre?
- Az Android kütyüi javíthatják a felhasználói élményt
- Hatékonyabb, mint az alkalmazás parancsikonjai
- Hozzon létre egy Android modult a hosszú távú elkötelezettség fokozására
- Gyűjtési alkalmazás widget létrehozása
- Készítse el a widget elrendezését
- A gyűjtemény widget feltöltése
- AppWidgetProvider: A widget konfigurálása
- Hozza létre az adaptert
- A widget életciklus-módszereinek meghatározása
- Új tartalom letöltése az onUpdate használatával
- onEnabled: A kezdeti beállítás végrehajtása
- Tisztítás az onDisabled segítségével
- A kész AppWidgetProvider
- Az AppWidgetProviderInfo fájl
- 1. android: previewImage
- 2. android: widgetCategory
- 3. android: InitLayout
- 4. android: resizeMode = ”vízszintes | függőleges”
- 5. android: minHeight és android: minWidth
- 6. android: updatePeriodMillis
- A kész AppWidgetProviderInfo
- Ne pazarolja a felhasználó kezdőképernyőjét!
- Adatok küldése a widgethez
- A widget regisztrálása a Manifestben
- Tesztelje widgetet
- Android widget előnézeti kép létrehozása
- Testreszabható kütyü: Konfigurációs tevékenység hozzáadása
- Hozza létre a konfigurációs tevékenységet
- A projekt tesztelése
- Csomagolás
Az operációs rendszer kezdeti napjaitól kezdve az Android kütyü lehetővé tette a felhasználók számára, hogy otthoni képernyőjük kényelmét használják. Tehát hogyan hozhat létre egy Android widget-et?
A fejlesztők számára a kütyü értékes értékes jelenlétet biztosít az alkalmazás számára a felhasználó kezdőképernyőjén. Ahelyett, hogy az alkalmazásfiókba helyeznék a látót, a felhasználók emlékeztetnének az alkalmazására minden egyes alkalommal az otthoni képernyőre pillantnak - miközben áttekintést kapnak az alkalmazás legérdekesebb és leghasznosabb tartalmáról.
A widgetek értékes jelenlétét biztosítják alkalmazásának a felhasználói kezdőképernyőn
Ebben a cikkben megmutatom, hogyan lehetne jobb felhasználói élményt nyújtani, miközben bátorítja a felhasználókat, hogy vegyenek részt az alkalmazásodban, egy Android widget létrehozásával! A cikk végére elkészített egy gördíthető gyűjtemény-modult, amely megjeleníti a teljes adatkészletet a felhasználói kezdőképernyőn.
Annak biztosítása érdekében, hogy elküldi a felhasználókhoz hasonló típusú eszközöket akar a kezdőképernyőn való elhelyezéshez egy konfigurációs tevékenységet is létrehozunk, amely lehetővé teszi a felhasználók számára a widget tartalmának, megjelenésének és funkcióinak testreszabását. Végül megmutatom, hogyan ösztönözheti az embereket a widget használatára, létrehozva egy Widget Preview képet, amely bemutatja a widget által kínált lehetőségeket.
Olvassa el: Fejlesztés összecsukható eszközökhöz: Mit kell tudni
Mik az widget-ek az Android-hoz?
Az alkalmazás widget egy könnyű, miniatűr alkalmazás, amely a felhasználó kezdőképernyőjén él.
Az Android kütyü számos tartalmat biztosíthat, de általában a következő kategóriák egyikébe tartozik:
- Információs widget. Ez egy nem görgethető eszköz, amely bizonyos információkat jelenít meg, például a mai időjárás-előrejelzést vagy a dátumot és az időt.
- Gyűjtemény kütyü. Ez egy gördíthető eszköz, amely a kapcsolódó adatok halmazát jeleníti meg, ListView, GridView, StackView vagy AdapterViewFlipper formátumban. A gyűjtési kütyüket általában egy adatforrás, például adatbázis vagy tömb támogatja.
- Vezérlő kütyü. Ezek a kütyü távirányítóként működik, amely lehetővé teszi a felhasználók számára, hogy kapcsolatba lépjenek az alkalmazásoddal, nélkül az előtérbe kell hoznia. A médiát, például a podcastot vagy a zenét játszó alkalmazásoknak gyakran vannak vezérlő widgetjeik, amelyek lehetővé teszik a felhasználó számára, hogy a Play, Pause és Skip műveleteket közvetlenül a kezdőképernyőről indítsák.
- Hibrid kütyü. Előfordulhat, hogy több kategóriából származó elemek egyesítésével jobb felhasználói élményt nyújthat. Például, ha egy vezérlő widget fejlesztett ki egy zenei alkalmazás számára, akkor biztosíthat Play, Szünet és Ugrás vezérlőket, de dönthet úgy is, hogy megjelenít bizonyos információkat, például a dal címét és előadóját. Ha úgy döntesz, hogy keverjük össze, akkor ne kerüljünk el! A kütyü általában a legjobb felhasználói élményt nyújtja, ha könnyű hozzáférést biztosít kis mennyiségű, időszerű, releváns információhoz vagy néhány általánosan használt szolgáltatáshoz. A hibrid kütyü könnyűségének fenntartása érdekében javasoljuk, hogy azonosítsa a widget elsődleges kategóriáját, fejlessze ki annak kategóriája szerint, és azután adjon hozzá néhány elemet a widget másodlagos kategóriájából.
Valóban szükségem van-e a projektem egy alkalmazás widgetre?
Számos oka van annak, hogy érdemes fontolóra vennie egy alkalmazás widget hozzáadását az Android projekthez.
Az Android kütyüi javíthatják a felhasználói élményt
Általános szabály, hogy minél kevesebb navigációs lépést kell elvégezni egy feladat elvégzéséhez, annál jobb felhasználói élmény.
Az alkalmazás widget biztosításával eltávolíthat több navigációs lépést az alkalmazás leggyakrabban használt folyamataiból. A legjobb esetben a felhasználók csak a kezdőképernyőre pillantva kaphatják meg a szükséges információkat, vagy pedig a vezérlő widgetben lévő gomb megérintésével hajthatják végre a kívánt feladatot.
Hatékonyabb, mint az alkalmazás parancsikonjai
Az alkalmazás-kütyü gyakran reagálnak az onClick eseményekre azáltal, hogy elindítják a társított alkalmazás legfelső szintjét, hasonlóan az alkalmazás parancsikonjához. A kütyü azonban közvetlen hozzáférést is biztosíthat egy alkalmazáson belüli meghatározott tevékenységekhez, például ha a widget Új fogadott értesítése megérinti, elindíthatja a társított alkalmazást az új, már nyitott alkalmazással.
Több hivatkozás beágyazása révén a widget elrendezésébe egyetlen kattintással hozzáférést biztosíthatsz az alkalmazás összes legfontosabb tevékenységéhez, és eltávolíthatsz még több navigációs lépést a leggyakrabban használt folyamatokból.
Több hivatkozás beágyazásával a widget elrendezéséhez hozzáférést biztosíthat egyetlen gombnyomással az alkalmazás összes legfontosabb tevékenységéhez.
Vegye figyelembe, hogy a kütyü csak a onClick eseményekre reagál, ami megakadályozza a felhasználókat, hogy véletlenül interakcióba lépjenek a widgettel, miközben elcsúsznak a kezdőképernyőn. Az egyetlen kivétel az, amikor a felhasználó megpróbálja törölni a widgetét az otthoni képernyő Eltávolítási művelete felé húzásával, mivel ebben a forgatókönyvben a widget egy függőleges ellop mozdulattal reagál.
Ezt az interakciót az Android rendszer kezeli, így nem kell aggódnia, hogy a vertikális ellop támogatást manuálisan bevezetje a widgetbe.
Hozzon létre egy Android modult a hosszú távú elkötelezettség fokozására
Az emberek meggyőzése az alkalmazás letöltéséről csak az első lépés a sikeres Android alkalmazás létrehozásához. Ha valószínűleg megragadja saját Android okostelefonját vagy táblagépét, és ellop az alkalmazás fiókjában, akkor felfedezhet több olyan alkalmazást, amelyet napokban, hetekben vagy esetleg akár hónapokban sem használott!
Olvassa el még:Az Android SDK Facebook használatának megkezdése
Miután sikeresen telepítette az alkalmazását a felhasználó eszközére, keményen kell dolgoznia annak érdekében, hogy továbbra is elkapja és élvezze az alkalmazását. Az alkalmazás jelenléte a kezdőképernyőn hatékony eszköz lehet a hosszú távú elkötelezettség előmozdításához, egyszerűen azért, mert állandó emlékeztetője annak, hogy az alkalmazás létezik!
A jól megtervezett widget az alkalmazás folyamatos hirdetéseként is szolgálhatja. Minden alkalommal, amikor a felhasználó a kezdőképernyőre pillant, a widgetnek lehetősége van arra, hogy aktívan ösztönözze őket arra, hogy ismét vegyenek részt az alkalmazásodban, az alkalmazás összes érdekesebb és leghasznosabb tartalmának bemutatásával.
Gyűjtési alkalmazás widget létrehozása
Ebben az oktatóanyagban összegyűjtött eszközprimitítet készítünk, amely tömböt gördíthető Lista nézetként jelenít meg.
Az alkalmazás-widget életciklusának nyomon követése érdekében ez a widget különféle pirítósokat is kivált, amikor mozog a különböző életciklus-állapotokon. Az oktatóanyag vége felé javítjuk widgetünket egy egyedi előnézeti képpel, amely megjelenik az Android Widget Picker alkalmazásában, és egy olyan konfigurációs tevékenységgel, amely lehetővé teszi a felhasználók számára a widget testreszabását, mielőtt az otthoni képernyőjükre helyeznék.
Hozzon létre egy új Android projektet a választott beállításokkal, és kezdjük el!
Készítse el a widget elrendezését
A kezdéshez definiáljuk a widget felhasználói felületét (UI).
Az alkalmazás kütyü egy folyamatban jelenik meg kívül alkalmazásával, így csak olyan elrendezéseket és nézeteket használhat, amelyeket a RemoteViews támogat.
Az elrendezés kialakításakor a következőkre korlátozódik:
- AnalogClock
- Gomb
- Kronométer
- FrameLayout
- Rácsszerkezet
- ImageButton
- Kamerák
- LinearLayout
- Fejlődésmutató
- RelativeLayout
- TextView
- ViewStub
- AdapterViewFlipper
- Rácsnézet
- Lista nézet
- StackView
- ViewFlipper
Vegye figyelembe, hogy a fenti osztályok és nézetek alosztályai nem támogatott.
Hozzon létre egy új elrendezési erőforrás fájlt, a list_widget.xml néven. Mivel az adatokat egy ListView segítségével jelenítjük meg, ez az elrendezés elsősorban a Ezután létre kell hoznunk egy adatszolgáltatót a ListView-hoz. Hozzon létre egy új Java osztályt, DataProvider.java néven, és adja hozzá a következőket: import android.content.Context; import android.content.Intent; import android.widget.RemoteViews; import android.widget.RemoteViewsService; import java.util.ArrayList; import java.util.List; import statikus android.R.id.text1; statikus android importálása.R.layout.simple_list_item_1; nyilvános osztályú DataProvider végrehajtja a RemoteViewsService.RemoteViewsFactory {Lista Android-widget létrehozásához több fájlt kell létrehoznia. Az első widget-specifikus fájlunk egy AppWidgetProvider, amely egy BroadcastReceiver, ahol meghatározza a különféle widget életciklus-módszereit, például a modult, amelyet a widget első létrehozásakor hívtak meg, és azt a módszert, amelyet a widget végső törlésekor hívtak meg. Hozzon létre egy új Java osztályt (Fájl> Új> Java osztály), amelynek neve CollectionWidget. A kezdéshez az összes eszközkészlet-fájlnak kiterjednie kell az AppWidgetProvider osztályra. Ezután be kell töltenünk a list_widget.xml elrendezési erőforrás fájlt a RemoteViews objektumba, és értesíteniük kell az AppWidgetManager alkalmazást a frissített RemoteViews objektumról: A nyilvános osztály CollectionWidget kiterjeszti az AppWidgetProvider {statikus érvénytelen frissítésAppWidget alkalmazást (kontextus kontextus, AppWidgetManager appWidgetManager, int appWidgetId) {// Az RemoteViews objektumot azonnali // // RemoteViews views = new RemoteViews (context.getPackageoutName;); setRemoteAdapter (kontextus, nézetek); // Kérje meg, hogy az AppWidgetManager frissítse az alkalmazás widget // appWidgetManager.updateAppWidget (appWidgetId, nézetek); } Mivel az adatokat egy ListView-ban jelenítjük meg, meg kell határoznunk a setRemoteAdapter () módszert az AppWidgetProvider-ben. A setRemoteAdapter () megegyezik az AbsListView.setRemoteViewsAdapter () meghívásával, de az alkalmazás-kütyüben való használatra készült. Ebben a módszerben meg kell határoznunk az AdapterView azonosítóját (R.id.widget_list) és annak a szolgáltatásnak a szándékát, amely végül az adatokat továbbítja a RemoteViewsAdapterhez - hamarosan létrehozzuk ezt a WidgetService osztályt. magán statikus érvénytelen setRemoteAdapter (Kontextus kontextus, @NonNull végleges RemoteViews nézetek) {Views.setRemoteAdapter (R.id.widget_list, új szándék (kontextus, WidgetService.class)); }} Az AppWidgetProvider-ben a következő modulok életciklus-módszereit is meg kell határoznunk: Az onUpdate () widget életciklus-módszere felelős a widget nézeteinek új információkkal történő frissítéséért. Ezt a módszert minden alkalommal hívják: Itt is regisztrál minden eseménykezelőt, amelyet a widgetnek használni kell. Az Android-widget frissítésekor fontos szem előtt tartani, hogy a felhasználók ugyanazon widget több példányát is létrehozhatják. Például, talán a widget testreszabható, és a felhasználó úgy dönt, hogy több „verziót” hoz létre, amelyek eltérő információkat jelenítenek meg, vagy hozzáférést biztosítanak az egyedi funkciókhoz. Az onupdate () hívásakor meg kell határoznia, hogy a widget minden példányát, vagy csak egy adott példányt frissít. Ha frissíteni szeretne minden példányt, akkor használhatja az appWidgetIds szoftvert, amely azonosító tömb, amely azonosítja az eszköz minden példányát. A következő részletben minden példányt frissítek: @A nyilvános érvénytelenség frissítése onUpdate-on (kontextus, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {// Frissítse a widget összes példányát // updateAppWidget (kontextus, appWidgetManager, appWidgetId); } super.onUpdate (kontextus, appWidgetManager, appWidgetIds); } Vegye figyelembe, hogy a kód egyértelműségének megkönnyítése érdekében ez az onUpdate () módszer jelenleg nem módosítja a modult. Az onEnabled () életciklus-módszert az ACTION_APPWIDGET_ENABLED válaszra hívják, amely akkor kerül elküldésre, amikor a widget példánya hozzáadódik a kezdőképernyőhöz a első idő. Ha a felhasználó két példányt hoz létre a widgetben, akkor az onEnabled () hívja az első példányt, de nem a második. Az onEnabled () életciklus metódusban kell elvégeznie a beállításokat, amelyek a widget minden példányához szükségesek, például létrehozni egy adatbázist, amely betölti a widget adatait. Megjelenítek egy pirítósot, így pontosan láthatja, mikor hívják ezt az életciklus-módszert: @A nyilvános érvénytelenség felülírása onEnabled (Kontextus kontextus) {Toast.makeText (kontextus, "onEnabled nevű", Toast.LENGTH_LONG) .show (); } Vegye figyelembe, hogy ha a felhasználó törli a widget összes példányát, majd létrehoz egy új példányt, akkor azt első példánynak kell besorolni, és az onEnabled () életciklus módszert ismét meghívják. Az onDisabled () metódus az ACTION_APPWIDGET_DISABLED válaszra hívódik meg, amelyet akkor aktiválnak, amikor a felhasználó törli a utolsó a widget példánya. Ebben a widget életciklus-módszerben meg kell tisztítani az onEnabled () módszerrel létrehozott erőforrásokat, például törölnie kell az onEnabled () fájlban létrehozott adatbázist. A kód egyértelműségének megőrzése érdekében egyszerűen csak egy pirítósot jelenítek meg minden alkalommal, amikor ez a módszer beindul: @A nyilvános void felülbírálása onDisabled (Kontextus kontextus) {Toast.makeText (kontextus, "onDisabled nevű", Toast.LENGTH_LONG) .show (); } A CollectionWidget fájljának most így kell kinéznie: import android.appwidget.AppWidgetManager; import android.appwidget.AppWidgetProvider; import android.content.Context; import androidx.annotation.NonNull; import android.content.Intent; import android.widget.RemoteViews; import android.widget.Toast; // Bővítse az AppWidgetProvider osztályból // public class CollectionWidget kiterjeszti az AppWidgetProvider {statikus void updateAppWidget (kontextuskontextus, AppWidgetManager appWidgetManager, int appWidgetId) {// betöltése az elrendezési erőforrás fájlt a RemoteViews objektumba (RemoteViews Views = new. RemoteViews Views = new. getPackageName (), R.layout.list_widget); setRemoteAdapter (kontextus, nézetek); // Tájékoztatja az AppWidgetManager alkalmazást a RemoteViews objektumról // appWidgetManager.updateAppWidget (appWidgetId, nézetek); } @A nyilvános void felülbírálása onUpdate (Kontextus kontextus, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {updateAppWidget (kontextus, appWidgetManager, appWidgetId); } super.onUpdate (kontextus, appWidgetManager, appWidgetIds); } @A nyilvános void felülbírálása onEnabled (Kontextus kontextus) {Toast.makeText (kontextus, "onEnabled nevű", Toast.LENGTH_LONG) .show (); } @A nyilvános void felülbírálása onDisabled (Kontextus kontextus) {Toast.makeText (kontextus: "onDisabled nevű", Toast.LENGTH_LONG) .show (); } privát statikus érvénytelen setRemoteAdapter (Kontextus kontextus, @NonNull végleges RemoteViews nézetek) {Views.setRemoteAdapter (R.id.widget_list, új szándék (kontextus, WidgetService.class)); }} Az alkalmazás-widgethez szintén szükség van egy AppWidgetProviderInfo fájlra, amely meghatározza számos fontos tulajdonságot, beleértve az eszköz minimális méreteit és annak frissítési gyakoriságát. Az AppWidgetProviderInfo fájlt a projekt res / xml mappájában tárolja. Ha a projekt még nem tartalmazza ezt a mappát, akkor létre kell hoznia azt: Ezután hozzon létre a collection_widget_info fájlt, amelyet AppWidgetProviderInfo-ként fogunk használni: Az AppWidgetProviderInfo fájlban a következő tulajdonságokat kell meghatároznunk: Ez az a rajz, amely képviseli az alkalmazás widgetjét az eszköz widgetválasztójában.A gyűjtemény widget feltöltése
AppWidgetProvider: A widget konfigurálása
Hozza létre az adaptert
A widget életciklus-módszereinek meghatározása
Új tartalom letöltése az onUpdate használatával
onEnabled: A kezdeti beállítás végrehajtása
Tisztítás az onDisabled segítségével
A kész AppWidgetProvider
Az AppWidgetProviderInfo fájl
1. android: previewImage
Ha nem nyújt előnézeti képet, akkor az Android az alkalmazás ikonját fogja használni. Annak ösztönzése érdekében, hogy a felhasználókat válassza a widget a Widget Picker közül, hozzon létre egy rajzot, amely megmutatja, hogyan fog kinézni a widget, miután megfelelően konfigurálta a felhasználó kezdőképernyőjén.
Az előnézeti kép létrehozásának legegyszerűbb módja az Android emulátorban található Widget Preview alkalmazás használata. Ez az alkalmazás lehetővé teszi a widget konfigurálását, majd egy kép létrehozását, amelyet felhasználhat az Android projektben.
Ezt a képet akkor készítjük, amikor befejeztük a widget készítését, így egyelőre ideiglenes előnézeti képként automatikusan létrehozott mipmap / ic_launcher erőforrást fogom használni.
2. android: widgetCategory
Az alkalmazás-kütyüket az App Widget-gazdagépen kell elhelyezni, amely általában az Android kezdőképernyője, de lehet harmadik fél indítóprogramja is, például az Evie Launcher vagy a Nova Launcher.
A 17 és 20 API szint között alkalmazási kütyüket lehetett elhelyezni a kezdőképernyőn vagy a lockscreen, de a lockscreen támogatás elavult az API 21. szintjén.
Az android: widgetCategory attribútum segítségével megadhatja, hogy az alkalmazás-widget elhelyezhető-e a kezdőképernyőn, a lezáró képernyőn (amelyet az Android „billentyűzárnak” nevez) vagy mindkettőt. Mivel az Android legfrissebb verzióinál nem lehet kütyüket elhelyezni a zárképernyőn, csak a kezdőképernyőt célozzuk meg.
A felhasználó magánéletének megőrzése érdekében a widget nem jeleníthet meg semmiféle érzékeny vagy személyes információt, amikor azt a zár képernyőn helyezi el.
Ha megadja a felhasználóknak azt a lehetőséget, hogy elhelyezzék a kütyüket a lezáró képernyőn, akkor bárki, aki a felhasználó eszközére pillant, láthassa a widget-et és annak tartalmát. A felhasználó magánéletének megőrzése érdekében a widget nem jeleníthet meg semmiféle érzékeny vagy személyes információt, amikor azt a zár képernyőn helyezi el. Ha a widget személyes adatokat tartalmaz, akkor érdemes megfontolnia külön kezdőképernyő és zárolási képernyő elrendezés megadását.
3. android: InitLayout
Ez az elrendezési erőforrásfájl, amelyet a widgetnek akkor kell használnia, amikor a kezdőképernyőre helyezte, amely a projektünk számára a list_widget.xml.
4. android: resizeMode = ”vízszintes | függőleges”
Az android: resizeMode attribútum segítségével meghatározhatja, hogy a widget átméretezhető-e vízszintesen, függőlegesen vagy mindkét tengely mentén.
Annak érdekében, hogy a widget megfelelő módon jelenjen meg és működjön sokféle képernyőn, javasoljuk, hogy engedélyezze a widget vízszintes átméretezését. és függőlegesen, hacsak nincs konkrét oka nem.
5. android: minHeight és android: minWidth
Ha a widget átméretezhető, akkor gondoskodnia kell arról, hogy a felhasználó ne zsugorítsa a widgetet arra a pontra, ahol felhasználhatatlanná válik. Használhatja a minHeight és a minWidth attribútumokat, hogy meghatározza azt a legkisebbet, amelyben az alkalmazás csökken, amikor a felhasználó átméretezi.
Ezek az értékek a widget kezdeti méretét is jelzik, tehát ha a widget nem méretezhető át, akkor a minHeight és a minWidth határozza meg a widget állandó méretét.
6. android: updatePeriodMillis
Az AppWidgetProviderInfo ezen kívül megadhatja, hogy a widget milyen gyakran kérjen új információkat.
A legkisebb támogatott frissítési intervallum 1800000 milliszekundum (30 perc) egyszer. Még ha rövidebb frissítési intervallumot is deklarál, a widget továbbra is csak félóránként frissül.
Noha érdemes lehet a legfrissebb információkat a lehető leggyorsabban megjeleníteni, a rendszer akarat felébreszt egy alvó készüléket, hogy új információkat szerezzen. A gyakori frissítések az eszköz akkumulátorán keresztül felgyulladhatnak, különösen azokban az időszakokban, amikor az eszköz jelentős ideig tétlen marad, például egy éjszakára. A lehető legjobb felhasználói élmény biztosítása azt jelenti, hogy egyensúlyt kell találni az akkumulátorfogyasztás korlátozása és az új információk ésszerű időn belüli rendelkezésre bocsátása között.
Azt is figyelembe kell vennie, hogy milyen típusú tartalmat jelenít meg a widget.
Azt is figyelembe kell vennie, hogy milyen tartalom jelenik meg az Android kütyüben. Például egy időjárási widgetnek csak naponta egyszer kell beolvasnia a frissített előrejelzést, míg a friss híreket megjelenítő alkalmazásnak gyakrabban kell frissülnie.
Ennek a tökéletes egyensúlynak a megtalálásához szükség lehet a widget frissítési gyakoriságának tesztelésére, és meg kell mérnie az akkumulátor élettartamára gyakorolt hatást, valamint a widget tartalmának időszerűségét. Ha van egy hajlandó tesztelõi csoport, akkor beállíthatja az A / B tesztelést is, hogy megnézze, vajon egyes frissítési frekvenciák pozitívabban vannak-e fogadva, mint mások.
Aalso így szól: AndroidManifest.xml mindent, amit tudnia kell
Végül, miután azonosította a tökéletes frissítési intervallumot, érdemes lehet rövidebb intervallumot használni az alkalmazás fejlesztése és tesztelése során. Például használhatja a lehető legrövidebb frissítési gyakoriságot (android: updatePeriodMillis = ”1800000 ″), amikor teszteli, hogy az alkalmazásod onUpdate () módszerének megfelelően működik-e, majd megváltoztathatja ezt az értéket, mielőtt alkalmazását nyilvánosságra hozza.
A kész AppWidgetProviderInfo
A kész gyűjtemény_widget_info.xml fájlnak így kell kinéznie:
Ne pazarolja a felhasználó kezdőképernyőjét!
Annak biztosítása érdekében, hogy a kezdőképernyő soha ne nézzen ki rendetlenségre, widgetünk némi párnázatot és margót fog hozzáadni. Ha a projekt még nem tartalmaz dimens.xml fájlt, akkor létre kell hoznia egyet:
- Kattintson a vezérlőgombra a projekt értékeinek mappájára.
- Válassza az Új> Értékek erőforrás fájlt.
- Adja ennek a fájlnak a méretet.
- Kattintson az OK gombra.
Nyissa meg a dimens.xml fájlt, és határozza meg a következő margó- és kitöltési értékeket:
Adatok küldése a widgethez
Ezután létre kell hoznunk egy widget szolgáltatást, amelynek feladata a gyűjtési adatok elküldése a widgetre.
Hozzon létre egy új Java osztályt (Új> Java osztály) a WidgetService néven, és adja hozzá a következőket:
import android.content.Intent; import android.widget.RemoteViewsService; a nyilvános osztályú WidgetService kiterjeszti a RemoteViewsService {@Orride nyilvános RemoteViewsFactory onGetViewFactory (szándékbeli szándék) {új adatProvider visszaadása (ezt, szándékot); }}
A widget regisztrálása a Manifestben
Most módosítanunk kell projektünk manifesztumát.
A kezdéshez nyissa meg a Manifest-et, és regisztrálja widgetet BroadcastReceiverként. Szükségünk van egy szándékszűrőre az android.appwidget.action.APPWIDGET_UPDATE művelethez:
Ezután meg kell határoznia az alkalmazás widget szolgáltatót:
Végül be kell jelentenünk azt a szolgáltatást, amely adatokat küld a widgetünkhöz, amely ebben az esetben a WidgetService osztály. Ehhez a szolgáltatáshoz az android.permission.BIND_REMOTEVIEWS engedély szükséges:
Tesztelje widgetet
Ha ezt az oktatást követi, akkor most rendelkezésére áll egy teljes gyűjtemény-eszközprimitív, amely adatkészletet jelenít meg a felhasználó kezdőképernyőjén.
Ha ez egy valós Android projekt volt, akkor általában az életciklus-módszerekre terjed ki, különösen az onUpdate () módszerre, de ehhez elengedhetetlen egy widget létrehozásához, amelyet telepíthet és tesztelhet Android-eszközén:
- Telepítse ezt a projektet egy kompatibilis Android okostelefonra, táblagépre vagy AVD-re (Android virtuális eszköz).
- Hosszan nyomja meg a kezdőképernyő bármely üres részét, és válassza a Widgets lehetőséget. ez elindítja a Widget Picker alkalmazást.
- Csúsztassa az ujját a Widget Picker segítségével, amíg meg nem találja az éppen létrehozott alkalmazás widgetet.
- Hosszan nyomja meg ezt a modult, hogy felvegye kezdőképernyőjére.
- Mivel ez az adott widget első példánya, az onEnabled () metódusnak futnia kell, és megjelenik egy “onEnabled nevű” pirítós.
- Átméretezze a modult. Ha beállít egy minimális támogatott méretet, akkor ellenőrizze, hogy a widget nem csökkentheti-e ezt az értéket.
- Ellenőrizze, hogy a ListView a várt módon görget-e.
- Ezután ellenőrizze az onDisabled () módszert a widget törlésével. Hosszan nyomja meg a modult, majd válassza az Eltávolítás a kezdőképernyőről lehetőséget. Mivel ez az adott widget utolsó példánya, az onDisabled () metódusnak futnia kell, és megjelenik egy “onDisabled hívott” pirítós.
Ez mindössze annyit kell, hogy működőképes Android alkalmazás-widgetet szállítson, de van néhány kiegészítés, amelyek gyakran javíthatják a felhasználói élményt. A következő szakaszokban arra buzdítjuk a felhasználókat, hogy válasszák ezt a modult a Widget Pickerből, és hozzanak létre egy olyan előnézeti képet, amely a widget legjobban mutatja be. Megmutatom azt is, hogyan lehet létrehozni egy teljesen testreszabható modult a konfigurációs tevékenység hozzáadásával a projekthez.
Android widget előnézeti kép létrehozása
Ha megragadja az Android készülékét, és átvált a Widget Picker segítségével, látni fogja, hogy minden modult egy kép ábrázol, amely általában azt mutatja meg, hogy hogyan néz ki ez a widget, miután konfigurálta a felhasználó kezdőképernyőjén.
Annak ösztönzése érdekében, hogy a felhasználó válasszon widgetet, előzetes képet kell készítenie, amely kiemeli a widget által kínált összes hasznos információt és funkciót.
Gyorsan és egyszerűen létrehozhat egy előnézeti képet az Android emulátorban található Widget Preview alkalmazás segítségével.
Vegye figyelembe, hogy a Widget előnézete nem szerepel a legújabb Android rendszerképeken, ezért AVD-t kell létrehoznia a Nugát (API szint 25) vagy korábbi használatával:
- Telepítse alkalmazását egy AVD-re, amely legalább API 25-ös verziót futtat.
- Nyissa meg az AVD alkalmazásfiókját, és indítsa el a Widget Preview alkalmazást.
- A Widget előnézete megjeleníti az AVD-re jelenleg telepített alkalmazások listáját; válassza ki az alkalmazást a listából.
- A widget most egy üres háttérrel jelenik meg. Töltsön el egy kis időt a widget átméretezésével és finomításával, amíg az nem a lehető legjobban megmutatja a widget nyújtotta lehetőségeket.
- Ha elégedett a widget megjelenésével és tartalmával, válassza a Pillanatkép készítése lehetőséget.
- A pillanatkép letöltéséhez váltson vissza az Android Studio alkalmazásra, és válassza az eszköztár Nézet> Windows eszköz> Eszközfájlkezelő lehetőséget. Ez elindítja az Android Studio eszközfájl-kezelőjét.
- Az Eszközfájlkezelőben keresse meg az sdcard / Download elemet. Az előnézeti képet a következő formátumban kell elmenteni: _ori_.png
- Húzza ki ezt a képet az Android Studio alkalmazásból, és dobja el könnyen elérhető helyre, például az asztalra.
- Adjon ennek a képfájlnak leíró nevet.
- Húzza a fájlt a projekt rajzolómappájába.
- Nyissa meg az AppWidgetProviderInfo fájlt, amely ehhez a projekthez a collection_widget_info.xml.
- Keresse meg az androidot: previewImage = ”@ mipmap / ic_launcher”, és frissítse azt az előnézeti kép hivatkozásához.
A widget ezt az új képforrást használja előnézeti képként:
- Telepítse a frissített projektet fizikai Android-eszközére vagy AVD-jére.
- Hosszan nyomja meg a kezdőképernyő bármely üres részét.
- Koppintson a Widgets elemre, amely elindítja a Widget Picker alkalmazást.
- Görgessen a widgethez; most a frissített előnézeti képet használja.
Testreszabható kütyü: Konfigurációs tevékenység hozzáadása
A konfigurációs tevékenység automatikusan elindul, amikor a felhasználó elhelyezi a widget minden egyes példányát a kezdőképernyőn.
Számos oka van annak, hogy miért érdemes konfigurációs tevékenységet hozzáadni a projekthez.
a kütyü általában a legjobb felhasználói élményt nyújtja, amikor hozzáférést biztosítanak az egyes felhasználók számára legfontosabb információkhoz vagy szolgáltatásokhoz.
Először, néhány kütyü kezdeti beállítást igényel, például a forgalmi figyelmeztetéseket megjelenítő widgetnek tudnia kell a felhasználó otthoni címét, ahol dolgozik, és az általában az ingázás idejét. Ezen információ megadásának valamilyen módja nélkül a widget teljesen haszontalan lehet!
Ezenkívül a kütyü általában a legjobb felhasználói élményt nyújtja, amikor hozzáférést biztosítanak az egyes felhasználók számára legfontosabb információkhoz vagy szolgáltatásokhoz. Ha hozzáad egy konfigurációs tevékenységet a projekthez, akkor a felhasználók számára választási szabadságot adhat pontosan mi szerepel a widgetben.
Még a viszonylag egyszerű testreszabások, például a widget háttér vagy betűtípus megváltoztatása is pozitív hatással lehetnek a felhasználói élményre - elvégre senki sem fogja értékelni azt a widgetet, amely vizuálisan összecsap a kezdőképernyőjének többi részével!
Senki sem fogja értékelni egy olyan modult, amely vizuálisan összecsap a kezdőképernyő többi részével!
Alternatív megoldásként néha lehet egy hosszú listát a tartalomról, amelyet fel szeretne venni a widgetbe, és igyekszik szűkíteni a lehetőségeket. A konfigurációs tevékenység egy módja annak, hogy minden ötletet jól felhasználhassa, anélkül létrehozása egy rendetlen, zavaró widget. Ne feledje, hogy a kütyü beállítása nem érzi magának a munkát, ezért ha konfigurációs tevékenységet nyújt, akkor javasoljuk, hogy korlátozódjon három konfigurációs opcióra.
Adjunk hozzá egy konfigurációs tevékenységet projektünkhöz!
Először is, a konfigurációs tevékenységünknek elrendezésre van szüksége, tehát hozzon létre egy új elrendezési erőforrás fájlt a config_activity.xml néven.
A következő gombokat fogom hozzáadni ehhez az elrendezéshez:
- Konfigurációs gomb. Valós életben ez a gomb valamilyen módon módosítja a widget, például hozzáadhat vagy eltávolíthat tartalmat, vagy megváltoztathatja a widget frissítésének gyakoriságát. A kód egyértelműségének megőrzése érdekében erre a gombra kattintva egyszerűen megjelenik a Konfigurációs beállítások pirítós.
- Beállítás gomb. Miután a felhasználó elégedett a widget konfigurálásával, ennek a gombnak a megnyomásával az újonnan konfigurált widgetet elhelyezheti kezdőképernyőjén.
Itt található a kész config_activity.xml fájl:
Hozza létre a konfigurációs tevékenységet
Most létre kell hoznunk a konfigurációs tevékenységet.
A kezdéshez hozzon létre egy új Java osztályt, melynek neve ConfigActivity. Ebben a tevékenységben ki fogjuk tölteni az App Widget ID-t abból a szándékból, amely elindította a konfigurációs tevékenységet. Ha ennek a szándéknak nincs widget-azonosítója, akkor be kell hívnunk a cél () módszert:
Szándék szándéka = getIntent (); Bundle extrák = intent.getExtras (); if (extrák! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); }
Ezután létre kell hoznunk egy visszatérési szándékot, át kell adnunk az eredeti appWidgetId-et, és meg kell állítanunk az eredményeket a konfigurációs tevékenységből:
Intent resultValue = új Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); Befejez(); }}}
Ha megad egy konfigurációs tevékenységet, akkor az ACTION_APPWIDGET_UPDATE műsor nem kerül automatikusan elküldésre, amikor a konfigurációs tevékenység elindul, vagyis az onUdate () módszer szokás akkor hívják, amikor a felhasználó létrehozza a widget példányát.
Annak biztosítása érdekében, hogy a widget naprakész információkkal és tartalommal készüljön, a konfigurációs tevékenység kell indítsa el az első onUpdate () kérést.
Íme a teljes ConfigActivity:
import android.app.Activity; import android.appwidget.AppWidgetManager; import android.os.Bundle; import android.widget.Button; import android.content.Intent; import android.view.View; import android.view.View.OnClickListener; import android.widget.Toast; a nyilvános osztályú ConfigActivity kiterjeszti a {@Oride védett void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState) tevékenységet; setContentView (R.layout.config_activity); setResult (RESULT_CANCELED); Button setupWidget = (Button) findViewById (R.id.setupWidget); setupWidget.setOnClickListener (új OnClickListener () {@Oreride public void onClick (View v) {handleSetupWidget ();}}); Gomb configButton = (gomb) findViewById (R.id.configButton); configButton.setOnClickListener (új OnClickListener () {@Oreride public void onClick (View v) {kezelésiConfigWidget ();}}); } magán érvénytelen kezelőSetupWidget () {showAppWidget (); } magán érvénytelen kezelőConfigWidget () {Toast.makeText (ConfigActivity.this, "Configuration options", Toast.LENGTH_LONG) .show (); } int appWidgetId; private void showAppWidget () {appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; Szándék szándéka = getIntent (); Bundle extrák = intent.getExtras (); if (extrák! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); } // TO DO: Végezze el a konfigurációt // Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); Befejez(); }}}
Miután létrehozta a konfigurációs tevékenységet, deklarálnia kell ezt a tevékenységet a manifesztban, és meg kell határoznia, hogy elfogadja-e az APPWIDGET_CONFIGURE műveletet:
Végül, mivel egy konfigurációs tevékenységre a csomag hatókörén kívül hivatkozunk, ezt a tevékenységet deklarálnunk kell az AppWidgetProviderInfo fájlban, amely ebben az esetben a collection_widget_info.xml fájl:
android: configure = "com.jessicathornsby.collectionwidget.ConfigActivity">
A projekt tesztelése
Itt az ideje, hogy tesztelje a kész projektet:
- Telepítse a frissített projektet egy fizikai Android-eszközre vagy AVD-re.
- Törölje a widget összes korábbi példányát, hogy megbizonyosodjon arról, hogy a legújabb verzióval dolgozik.
- Hosszan nyomja meg a kezdőképernyő bármely üres területét, és válassza a Widgets lehetőséget.
- Keresse meg widgetjét a Widget Picker alkalmazásban, és hosszan nyomja le a kiválasztáshoz.
- Dobja el a widgetet a kezdőképernyőn. A konfigurációs tevékenységnek automatikusan el kell indulnia.
- Kattintson egy kattintásra a Konfiguráció végrehajtása gombra, és megjelenik a Konfigurációs beállítások pirítós, amely megerősíti, hogy ezt az interakciót sikeresen regisztrálták.
- Képzelje el, hogy megcsinálta a widget beállításait, és készen áll arra, hogy elhelyezze a kezdőképernyőn; érintse meg a Create the Widget gombot, és ezt a modult sikeresen el kell készíteni.
Letöltheti a kész gyűjtemény-widget projektet a GitHubból.
Csomagolás
Ebben a cikkben létrehozott egy görgethető gyűjtemény-modult, amely megjeleníti az adatkészletet a felhasználó kezdőképernyőjén.
Ha folytatni akarja a projektet, akkor megpróbálhatja hozzáadni saját kódját az onUpdate () módszerhez, és létrehozhat egy olyan modult, amely új információkkal frissül az AppWidgetProviderInfo fájlban megadott időközönként (gyűjtemény_widget_információ).
Ha létrehoz egy Android-modult, akkor mindenképpen ossza meg alkotásait az alábbi megjegyzésekben!
