- Hivatalosan is bemutatta a Google a Pixel 6a-t
- Samsung Galaxy S24 Ultra - ha működik, ne változtass!
- Friss koncepciót hoz a Nothing Phone (3)
- Xiaomi 15 Ultra - kamera, telefon
- Íme az új Android Auto!
- Samsung Galaxy S25 Ultra - titán keret, acélos teljesítmény
- Xiaomi 15 - kicsi telefon nagy energiával
- iPhone topik
- Azonnali mobilos kérdések órája
- Yettel topik
Új hozzászólás Aktív témák
-
thon73
tag
Az utolsóként indított app-okra lenne szükségem. Van egy príma billentyűzetem, és elhelyeznék rajta egy gombot, amivel az aktuális és az az utolsó app között tudnék ide-oda váltogatni. (Kb, mint a HOME hosszan, kiválaszt stb. - csak sokkal gyorsabban. Pl. két szövegen tudnék dolgozni; ilyesmi.)
Az ActivityManager.getRunningTasks a tudomány szerint tiltásra került Lollipop alatt.
Találtam egy getRunningAppProcesses() metódust, de:
1. azt írja, hogy csak debugra szabad használni (miért is?)
2. nem jövök rá, hogy miként tudom kiszedni belőle az ELŐZŐ app-ot.
Tudtok valami megoldást erre? Vagy esetleg valami más módszert, ami elkerülte a figyelmemet?
-
thon73
tag
A kérdés csak az, hogy miként lesz belőle kettő. Látom, hogy valamiként a headerrel kellene kombinálni, de vagy a bal oldalra nem tudok beállítási lehetőségeket tenni, vagy a jobb oldallal nem kezd semmit. Bizonyára én tolok el valamit, amire ebből nem jövök rá.
Nem ismersz véletlen valami oldalt, ahol működő megoldás van? -
thon73
tag
Láttam egy olyan preferences megoldást, ahol egy osztott képen (nyilván fragmentben) a bal oldalon voltak a "fő" beállítási lehetőségek, melyekhez csoportonként a jobb részen más és más albeállítási lehetőségek jelentek meg. Ez nagyon tetszett, de nem emlékszem a program nevére, hiába kerestem. (Telon meg nem csinál ilyet persze)
Van erre valamilyen egyszerűsített mód, vagy esetleg valaki találkozott egy ilyen tutoriallal? ("Kézzel" meg tudom oldani, de szerintem kell legyen erre valami erősan automatizált módszer, amit nem látok. Vagy legalábbis nem látok át.) Előre is köszönöm!
(Ott tartok, hogy az Activity EGY fragmentet simán megjelenít, amit xml-ből feltölt.)
-
thon73
tag
Van itt esetleg valaki, aki járatos az InputConnection kezelésében?
Az Android dokumentáció nem mindig egyértelmű számomra, a web meg elég üres ebben a kérdésben. Próbálkozással, source-okkal sok mindent kilogikáztam, de néhány kérdést szívesen megtárgyalnék, ha van valaki szintén érdeklődő...
-
thon73
tag
Lehet, hogy hülyeséget kérdezek.
Ha csupán egy tizedes pontosság kell, akkor nem lehet kerekítéssel használni a double-t? Mert a hiba mindig csak a sokadik értéken jelentkezik?
((Én egyébként ilyen "kis" értékeknél szoktam int-et is használni, 100 v. ezerszeres szorzóval. Pl. képernyőméret és szövegméret kiszámításánál.))Mondjuk, biztos, hogy a BigDecimal a legpontosabb, csak igen kacifántos. Na jó, ez nem igazi androidos kérdés.
-
thon73
tag
válasz
rgeorge
#3331
üzenetére
Köszönöm az IntDef ötletet, ezt korábban nem olvastam.
Megtaláltam az "ideális" megoldást:
Amikor csak a korlátozott számú elemre van szükség, akkor az IntDef-et fogom használni. ("hagyományos" enum)
Ha az enumnak szüksége van metódusokra is (vagy valami működésre, mint most), akkor meg azt!
to Karma:
A linkeket is köszönöm, nagyon hasznosak. Ekkora memórianövekedésre nem gondoltam, így persze, hogy nem jelez. Egyébként a doksi még mindig tartalmazza a 16 Mbyteot is (Igaz, hozzáteszi, hogy ha 2.2-re is akarunk fejleszteni), és az enum szigorú tiltását is.
-
thon73
tag
Igen, többek között pont ezért szerettem volna enum-ot használni. Rosszul fogalmaztam: már a C-ben is nagyon szerettem, amikor még tized ennyit sem tudott.Mondjuk azt még mindig nem értem, hogy pontosan mi is az, ami olyan "nagy". Egy integer konstansnál nyilván nagyobb, de egyébként éppen pont akkora kell legyen, mint egy másik objektum-hivatkozás (mármint egy osztálypéldányban.)
Vagy az osztály létrehozásához szükséges nagyobb terület? De számít ez az egyszeri fél-egy kilobyte?Most már egy egyre speciálisabb billezeten ügyködünk, ahol eredetileg 1000 billentyűvel számoltam. Ha ezt beszoroztam egy-egy osztálypéldánnyal, akkor elég elképesztő értéket kaptam. (Többet, mint az első számítógépem agya, pedig ez csak egy billentyűzet.)
Viszont magát a billentyűzetet képként jeleníti meg. Nekem csak kb. félmillió képponttal kell számolnom, de az új gépeken ez megtöbbszöröződött. A képek mérete mellett eltörpül a - humán fogalmak szerint - gigantikus adatmennyiség. (jó, ettől még nem kell pazarolni.)
Viszont rögtön jött ebből egy másik kérdés is: a dokumentáció óvva int a képek gátlástalan használatától, mert elfogy a terület. Nem töröltem ki az elavult képeket (véletlenül), és érdekes módon nem kapok hibaüzenetet még sok-sok egész képernyőnyi tárolt kép mellett sem.
Megváltozott vajon a memóriakezelés, és nagyobb területet kap a program? A dokksi szerint 16 mbyte körül van minden program lekorlátozva, aminek már számításaim szerint el kellett volna fogynia. -
thon73
tag
Meg tudná mondani nekem valaki az igazságot az Enum-ról? Csak a vitákat olvasom.
Egy négy elemű állapotot kell tárolnom (ON OFF WAIT HOLD), de ezt mintegy 1000 elemben, ahol az osztálynak csak egyetlen másik belső változója van, egy String. (lehet, hogy még lesz valami flag-szerű apróság)
Érdemes enum-ot használni, vagy tilos, ahogy az android útmutatja?
Ha tilos, akkor int-et használjak, vagy nyerek valamit egy byte alapú konstanssal.
Technikailag bármelyik elkészíthető, csak melyik a jobb?
Az érték szigorúan belső, az osztály belső állapotát regisztrálja. Kifelé majd csak egy ACTIVE vagy INACTIVE jelzés megy, ez a belső osztály csak azt írja elő, hogy ez mikor menjen ki.
Előre is köszönöm!
((Megjegyzem: a program képeket is használ, amik még ezen a tenyérnyi képernyőn is olyan hatalmasak, hogy az adatok mennyiség egyetlen kép mellett is eltörpül. Ezért törpölök azon, hogy kell-e foglalkoznom a memóriával?))
-
thon73
tag
Hát, ne egy hétköznapi billentyűzetre gondolj. Valójában akivel terveztük/teszteltük könyveket ír rajta több nyelven. Az eredetileg gigantikusnak gondolt határértékek a keze között akadállyá váltak: jelenleg 10 (külön keskeny és széles) layout a teszt, akár több, mint 1000 tényleges billentyűvel.
Ha ehhez hozzávesszük, hogy egyetlen billentyű leírásához akár 20 token is kellhet; ill. hogy ez legalább 2500 objektum; ráadásul egy igen részletes log is tartozik hozzá - akkor már nem is olyan sok az az idő. De az oroszlánrészét az objektumok veszik el, meg persze GC is dolgozik közben - a log tanúsága szerint.Mindegy, három próbálkozáson keresztül jutottunk ide, és ez jónak tűnik: nagyon gyorsan és könnyen módosítható, és mindent tud, amit szeretnénk. No persze, az okostelefon elgondolásba ez a (mondjuk log nélkül talán) 10 másodperc már nem fér bele, tegyük hozzá a három sem. Ezért szeretném pontosan ezt: szétválasztani a kettőt. Akár install során legyártja a szükséges adatokat, aztán a mentés meg a töltés már nem sok idő.
A Broadcast ötleten is gondolkodtam (ez jó, hogy példa is van hozzá), de az egyik előző elgondolásban az előző karakter átírását a DELETE majd ÚJKARAKTER elküldésével oldottam meg. legnagyobb meglepetésemre teljesen összekeveredett a sorrend, az elküldött értékek nem ugyanabban a sorrendben érkeztek meg. (A doksi csak arra hívja fel a figyelmet, hogy ez ún. IPC - vagyis nagyon lassú. De keveredésről nem volt szó.) Megoldható persze, egy blokkban kell a kettőt (néha többet) elküldeni. Épp csak attól tartottam, hogy a Broadcast még tovább rontja ezt az időt - talán az editor kellene a receiver legyen, de ez persze nem realitás.
Ebben a Broadcast megoldásban elmélyedek, mennyire nehéz bele-aplikálni. (Loadernél használtam, ott nagyon jó volt)
Még egy kiegészítés:
Amúgy a Broadcast megoldás is singletonnal operál a példában (ami gyári); no ezt csak azért írom, hogy csak azért betenni, hogy egy másik singleton-szerű megoldást kiváltson, lehet h. felesleges.Szerintem kipróbálom mind a hármat (referncia átadása - service elérése singletonként - broadcast; aztán meglátom, mennyire idő/helyigényes és mennyire dönti romba a kód szépségét
-
thon73
tag
Így már értem, és az utolsó szaváig egyet is értek vele. Az ördög az Android felépítésében rejlik, ezért csak a konkrét részekkel foglalkozom, a többi az absz. úgy van, ahogy írod.
Az InputMethodService felelős a billentyűzetért, ami ugye a képen van, tehát UI. Sajnos ez a Service igen gyengén dokumentált, többnyire a forráskódból meg próbálkozásokból jöttem rá egy-két dologra.
A mi szempontunkból fontos: a billentyűzet kiválasztásakor elindul a service és örökön-örökké él, amíg új billentyűzetet nem választ ki a felhasználó. No, és persze egyetlen példányban él. De ha szigorúan akarok fogalmazni: nem singleton, legfeljebb hasonló.
A service elindításakor szükség van valamilyen adatstruktúrára, ami a billentyűzetet reprezentálja. Az első megvalósításban ezt a struktúrát egy leírófájl alapján maga a service készíti el; ami leginkább idő. Ez a rész háttérszálon fut, de akkor sem tudom a billentyűzetet használni, amíg kész nincs. Ez persze idő, akár 10-20 másodperc is lehet; igaz csak a billentyűzet legelső kiválasztásakor kell kivárni. Nem tudom külön előkészíteni, mert a konkrét gép adatira is szüksége van. Viszont ezt szerettem volna úgy különválasztani, hogy mondjuk egy program legenerálja a használható adatstruktúrát (oké, ez egy fél perc), aztán azt az adatstruktúrát már azonnal tudja használni a service.
A speciális View egyik metódusa (onTouch()) kerül meghívásra érintéskor, egy másik (onDraw()) rajzoláskor. Az eddigieket nem én találtam ki, ez gyárilag így van.
Természetesen az onDraw() is eljut a példánkban Button-ként szereplő osztályig, ami megrajzolja a billentyűt (ennél kicsit bonyolultabb a dolog, mert egy köztes képet használ, de ez nem érdekes), és persze az onTouch() végrehajtása is a Button()-on keresztül történik, pontosabban a Text és Key további osztályokon, mert egy Button (joystick pl), akár négy ilyet is tartalmazhat. A lényeg csakis annyi, hogy az egész hosszú struktúrán végiggörgetem a referenciát, egészen pontosan úgy, ahogy írod. Mert ugyanis a leütött billentyűt CSAK a legelsőként szereplő Service tudja elküldeni. Van emögött persze logika, de néhány lépésben nehéz megfelelni neki.
A végső kérdés abszolút android specifikus: ennek a nem-singelton, nem-teljesen-standard-service, nem-minden-ízében-ismert InputMethodService-nek a referenciáját - vagyis inkább annak az átadását ki tudom-e kerülni valahogy. Magával az InputMethodService-szel nagyon kevesen foglalkoznak (szerintem), ezért örülnék, ha lenne valakinek tapasztalata vele.
Az állapot kérdésére meg nem tudok válaszolni. Ez egy bővített gyári osztály - fogalmam sincs arról (és doksi sincs), hogy egészen pontosan hogyan viselkedik. Azért persze valamennyit már tudok róla, csak félek, ez kevés, hogy egy ilyen huszárvágást bátran megcsináljak.
Az apróságokra:
jogos, én sem text-nek hívom, hanem packet-nek, amiből kettő van: vagy stringet vagy hard-keyt (kódot) tudok átadni. De ez a referencia utazása szempontjából csak még egy lépcső...A felsorolt opciók közül jelenleg 1-es működik. 2-est érzem megvalósíthatónak. A 4-es a kérdés, van-e ilyen, esetleg 3-assal kombinálva.
((A programozási cikket sajnos már nem találtam meg. Én magam nem vagyok elég felkészült, hogy bármi ilyen vitában részt vegyek, de a cikk nagyon érdekes volt. A "lineárisra" emlékszem, lehet, hogy rosszul idéztem, minden estre számomra a nem objektum-orientált, nem event-driven struktúrát jelentette (mondjuk basic
?). Nem ide tartozik, de nagyon tetszett a hasonlat, amit az egyik fél alkalmazott: Az objektum orientált programozás nagyon jó, de ha szükség van egy banánra, akkor meg kell teremteni hozzá a majmot is, meg az egész őserdőt. Bocs, ha ez se pontos. És még egyszer: részemről ez semmilyen állásfoglalás, tényleg nem tudok mit mondani róla; épp csak feldobtam, hogy ilyen is van a nap alatt.))Nagyon köszönöm a választ, mert segítettél továbbgondolni, és így a probléma is sokkal jobban kezd körvonalazódni bennem!
-
thon73
tag
Köszönöm. Bár ezzel a válasszal nem sokra mentem.
Megpróbálom kicsit érthetőbben elmagyarázni. Az InputMethodService több billentyűzet adatait tartalmazza a nagyjából a következő módon:
InputMethodService - KeyboardView - GeneralKeyboardData - Keyboard - Button - Text
Természetesen egy kicsit összetettebb az egész, de a sor minden egyes gomb esetén ezen alaposztályok leszármazottaiból áll össze. A sor végén álló "Text" pl. definiálja az "A" karaktert (néhány egyéb tulajdonsággal, pl. hogy . után legyen nagy, meg ilyesmi.)
A mi szempontunkból az egyetlen lényeges dolog, hogy amikor a "Text" osztály el szeretné küldeni az 'A' karaktert, akkor az InputMethodService osztály metódusaira van szüksége. (Amire viszont senki másnak.)
Eddig pont ugyanúgy oldottam meg, ahogy pl. a Context-nél történik (Tehát nem a service-t szerettem volna contextből kinyerni.), vagyis az InputMethodService szépen végigutazott az egész soron, és az összes "Text" példány tárolta a hivatkozást, hogy tudjon kommunikálni.
A változáson pedig azért kezdtem el gondolkodni, mert szerettem volna az egész adatstruktúra legenerálását leválasztani a Service-ről. Emiatt viszont az InputMethodService nem áll rendelkezésre akkor, amikor az adatstruktúra elkészül.
Több lehetőséget találtam:
Amikor a kész adatstruktúrát a Service-hez kapcsolom, végigmegyek az összes elemen és megadom az InputMethodService-t.
Vagy egyedül a GeneralKeyBoardData (az adatstruktúra legalsó eleme) kapja meg, és a Text ettől kérdezi le.
Vagy valahogy kiszedem az InputMethodService hivatkozását magából az InputMethodService-ből, amiből egyébként egyetlen van, és addig folyamatosan él, amíg nem váltok másik billentyűzetre (ilyenkor viszont az adatstruktúra sem létezik tovább.)Amúgy eddig az "erőltetett objektumokkal" szépen működik, de azt gondoltam, kell legyen ennek egyszerűbb módja is. Csak éppen még nem jöttem rá, mi az, ezért kértem segítséget az utolsó elgondoláshoz.
((A fentiektől függetlenül filozófiailag "sok hülye meg erőlteti itt az objektumokat" kijelentésnek igen komoly háttere van. Nagyon sok, nálamnál sokkal komolyabb programozó vitatja az objektum-orientált programozás előnyeit szemben a hagyományos, lineáris programozással. Mielőtt mindenki nekem ugrana és szétszedne, nem állást foglaltam mellettük, csak tényként megemlítettem ezt az iskolát is. Én ugyan nem tudom megítélni, de valószínűleg amúgy a java egy objektum-orientált android környezetben nem is alkalmas erre.))
-
thon73
tag
Véleményt szeretnék kérni:
Van egy Service (InputMethodService). A feladatokhoz a Service metódusai szükségesek. Ezért egy elég gigantikus (adat) osztályhalmaz (melyet a Service rak össze) minden egyes példányának átadtam a Service-t, hogy meg tudja hívni a metódusait. Kicsit hasonlóan, ahogy a Context utazik.De:
A Service egyúttal egy singleton is. Megtehetem-e, hogy a Service-n belül egy static metódus visszaadja magát a service-t, és akkor nem kellene az egész osztály-kaszkádon végig átadnom a címét?
Igazából nem látom, hogy ez miért ne működne (ugyanúgy mint egy sima singletonnál), de valamiért mégsem látok erre példát. Pl. a context-et miért nem oldották meg ugyanígy?
Köszönöm, ha útba igazítotok!
-
thon73
tag
Egy fél napos keresgélés után a következőt találtam:
A build.gradle file-ban a classpath 'com.android.tools.build:gradle:1.0.0' bejegyzésben helytelen a verziószám, és magától nem javítja. Kézzel kell kicserélni 1.1.0-re.
Láss csodát, azóta működik!
Gondoltam, megosztom, hátha valakinek még hasznára lesz. Úgy tűnik, ez a hiba nem túl gyakran jelentkezik. -
thon73
tag
Technikai segítséget szeretnék kérni:
Android Studio 1.3 frissítés után a build leáll a következő hibával:"...
> Could not get resource 'https://jcenter.bintray.com/com/android/tools/build/gradle/1.0.0/gradle-1.0.0.pom'.
> Could not HEAD 'https://jcenter.bintray.com/com/android/tools/build/gradle/1.0.0/gradle-1.0.0.pom'.
> Connection to https://jcenter.bintray.com refused"Először proxy hibára gyanakodtam, de közvetlenül sem tudom a kívánt oldalt megnyitni. Pontosabban hol meg tudom, hol meg nem.
Mit lehet ilyenkor tenni?
Előre is köszönöm. -
thon73
tag
Bocs, még mindig a WACOM által okozott ACTION_CANCEL-nél vagyok leragadva.
Sehol nem találok info-t arról, hogy miként működik az ACTION_CANCEL multitouch esetén. Ugyanis ilyenkor (vagyis, ha az SPen közelít) egyetlen eventben van összefoglalva az összes touch ACTION_CANCEL megjelelöléssel. Más módon pedig nem tudtam ACTION_CANCEL-t előidézni.
Kérdésem:
AZ ACTION_CANCEL esetén minden multitouch érintés megszakad, avagy lehet olyan szituáció, hogy csak egyetlen érintés szakad meg, míg a többi továbbmegy? (Vagyis ACTION_CANCEL esetén ki kell-e értékelnem az összes event-ben lévő érintést, vagy simán eldobhatom az összeset? Köszönöm! -
thon73
tag
Köszi! Nyilván azért, hogy rátehénkedhessek közben az érintőpanelre
Multitouch esetén viszont ez érdekes kérdéseket vet fel, mert lehet, hogy a felhasználó ujja még ott van a módosító billentyűn, amivel a stylus érintését módosítaná. Több billentyűzeten megnéztem, ez a probléma megvan - és technikailag nyilván megoldhatatlan. Majd kigondolom, hogy melyik feltételezés (tartja/elengedi) okozza a kisebb hibát... -
thon73
tag
Multitouch kapcsán tapasztaltam, hogy ha stylussal (Note) közelítek, akkor minden addigi touch megszakad egy ACTION_CANCEL kóddal.
Ez tartalmaz egy pozíciót is, ami viszont y irányban kb. 100-zal el van tolva.
Tapasztalta ezt már valaki?((Csak kíváncsi vagyok. Egyébként kihagytam a cancel mellett a pozíció ellenőrzést, ami előtte benne volt - de ettől még érdekelne, hogy az én készülékemben van a hiba, vagy ez általános android tulajdonság...))
-
thon73
tag
Egy custom View.onTouchEvent() metódusban multitouch eseményt szeretnék kezelni. Amikor a második (vagy további) DOWN érintés is megtörténik, akkor az ACTION_POINTER_DOWN adatok között az összes már lent lévő pointer adatait is megkapom.
Meg lehet-e állapítani valahogy, hogy az érintések között melyik az új érintés? Vagy kizárólag úgy, ha számon tartom a már folyamatban lévő érintések id-jét?
Köszönöm!
-
thon73
tag
Van megint egy izgalmas kérdésem, hátha valaki ráharap.
Van egy csodás "custom" billentyűzetünk, még fejlesztés alatt (de ha bárki szeretne próbálkozni vele, szívesen megosztom.) Cikk itt.
Van egy ismerősünk ínhüvelygyulladással, és ennek kapcsán felmerült, hogy jól tudná használni ezt a billezetet pc-vel is.
Meglepetésemre a piac tele van a tabletet egér-billentyű kombókká tevő programokkal.
DE!
Az összes (vagy legalább az összes megnézett) ilyen program billentyűkódot használ, tehát alkalmatlan unicode átküldésére. Egyszerűbben: alkalmatlan ékezetes, pl. magyar karakterek átvitelére. (Persze lehet a kiosztásokkal kavarni.)
Viszont találtam megoldást pl. ITT Vagyis, olyan billentyűzet kombinációt használ, amivel unicode beírható. Na, persze, a billentyűzet oldal is használhatna ilyet...
Úgy tűnik, mégis az lenne a legegyszerűbb, ha valami wifis kommunikációval (azonos hálózatból) készítenék egy ilyen együttmüködő programpárt (android és pc oldal).
Feladat: android oldalról átküldeni az unicode kódot, azt elkapni a pc oldalon és a megfelelő karakterkombinációval szimulálni.
A gondom az "átküldeni" résszel van, ill. a pc oldallal. Soha nem foglalkoztam ilyesmivel. Tudna valaki egyszerű kiindulási pontot adni, amivel nem kell a teljes netes kommunikációt áttanulmányoznom?
Ha esetleg valakit a kérdés tényleges megvalósítása is érdekel, az is megoldható (javadalmazással együtt).Előre is köszönet minden útmutatásért és ötletért.
-
thon73
tag
Csak a "minimális" rendszerigények tisztázása végett:
Intel Celeron J1900 + 4 GB Ram + SSD mellett az Android Studio minden további nélkül dolgozik. A "kis" teljesítmény (mondjuk i5-höz képest) érezhető a sebességben, de nem zavaróan számottevő.
Szerintem a processzornál fontosabb a memória - ideértve a hátteret (SSD) is.
((Egyébként ez a felállás még ahhoz is elegendő, ahogy AS és Eclipse együtt fusson, bár az utóbbit kizárólag régebbi kódok megtekintésére nyitottam meg.)) -
#3142
thon73
tag
WonderCSabo
#3141
thon73
tag
válasz
WonderCSabo
#3141
üzenetére
A hatszögletű billentyűzettel bíbelődök. A billentyűzet teljesen szabadon definiálható. Értelemszerűen a "széles" billentyűzet csak "széles" képernyőn használható, míg a "keskeny" a "keskeny" és "széles" képernyőn is. Viszont az fontos, hogy a billentyűk mérete megmaradjon, mert úgy könnyebb írni.
A lényeg, hogy landscape módban is jó lenne tudnom a portrait mód szélességét. És persze a magasságát is, mert annak arányában ellenőrzi a billentyűzet magasságát.
Nem volt egyszerű, de a "real" vagy teljes méretet (ami nem feltétlenül a fizikai", már meg tudom szerezni. Az onMeasure.ben megkapom a tényleges ablakméretet is (és ezt használom). Éppen csak landscape és portrait módban az onMeasure-ben kapott adatok a screen-dekor miatt különböznek (bár nálam csak statussor van), és ezt lenne érdemes tudni.
Végül arra jutottam, hogy minden elfordítás után az onMeasure-nek megfelelő képet gyártok. Csak ez ugye tök fölösleges, mert közben a méretek meg nem változnak...
-
-
thon73
tag
Van egy örökifjú kérdésem: honnan lehet tudni, hogy mekkora a rendelkezésre álló képernyő?
Már tudom, hogy a különböző API-k mellett hogyan kérdezhetem le a teljes képernyőméretet (displayMetrics.width/heightPixels; display.getRawWidth/Height; display.getRealSize), meg azt is, hogy mekkora a View számára rendelkezésre álló terület.
DE!
Nekem valójában arra lenne szükségem, hogy mekkora a rendelkezésre álló terület álló és fekvő módban. Ebből azonban csak az aktuális mód képernyőméretét tudom megszerezni. Honnan lehet megtudni a másikat? Köszi. -
thon73
tag
((to Laslie92: apk pü-ben ment!))
Támadt egy ötletem, amit szeretnék veletek megvitatni. Korábban valaki kérdezte a titkosítást, és a szummázat az lett, hogy androidon, 6-10 betűs kulcsszavakkal lehetetlen megoldani.
Az alaphelyzet a következő:
- a titkosítás feloldásához nem szeretnék túl sokat gépelni, de mondjuk 12-16 karakter megfelelő
- maga a titkosítás legyen viszont sokkal nagyobb erősségű
- a program saját célra kell, vagyis a módszer nem lesz Play-en keresztül hozzáférhető (bár nyilván valamekkora körben: család, barátok stb. használható)A gondolatom a következő:
A gépen vannak gigantikus méretű, nem változó file-ok (legyen mondjuk könyv, de lehet zene, film stb. Lényeg, hogy bináris értelemben változatlan, könnyen visszaszerezhető.)
A kód maga ennek a könyvnek/filenak egy hosszabb részlete. A kódot a pozíció megadásával választom ki (legyen mondjuk 4 alfanumerikus karakter; azzal már legalább 4 megányi címet kiválaszthatok.
Ezt a "fő" kódot is elfedem egy rövid, mondjuk 6 karakteres kóddal.Létrehozok egy ál-programot, ami csinálhat bármit, pl. bioritmust számolhat, kiírhatja, hogy "hello világ"; a lényeg: rejtett módon megadható benne a fenti 10 karakteres kód, amivel a valódi, az adatokat kezelő programnak rendelkezésére bocsájtja a könyvből/file-ból kivágott, másodlagos kóddal már átalakított "hosszú" kódot. Az álprogram ezt csak egy ideig teszi meg, utána törli az adatait.
A fő program akkor tud dekódolni, ha az ál-program által szolgáltatott kód rendelkezésre áll.
További védelmi lehetőség, hogy nem megfelelő kezeléskor a "nagy" file-t is törli a rendszer. Ez mondjuk azért felesleges, mert ennyi erővel az adatokat is törölheti. Csak az adatok visszaállítása lehetetlen, a nagy file viszont visszaállítható véletlen törlés esetén.A felhasználó szempontjából az adatok használatához:
El kell indítani az ál-programot, be kell írni a 10 karaktert.
Ezt követően az adatok - egy ideig - használhatóak.Maga az adat közel feltörhetetlen biztonságban van. Tudjuk, hogy ez nem igaz, hiszen az elérést csak egy tíz karakteres szekvencia biztosítja, ám ehhez a szekvenciához ismerni kell az ál-program működését és a hosszú kódot tartalmazó file-t is.
Véleményetek szerint ezzel a módszerrel mennyivel növeltem meg az adataim biztonságát a kereskedelemben hozzáférhető programokhoz képest? Vagy van valahol olyan hiba, amire nem gondoltam?
Köszönöm, ha valaki töri a fejét rajta!
-
thon73
tag
válasz
laslie92
#3106
üzenetére
Az előző témához:
Laslie, Te most el akarod kezdeni az androidot, vagy ez az egyetlen apk kell? Vagy egyáltalán mire kell, magadnak?
Mert ha éppen nem akarsz belevágni, akkor ezt a rendkívül összetett kódot bárki lefordítja itt neked, pl. én is. De az írója nem fordította le? Vagy Te írtad?
Bocs, hogy ennyit kérdezek, de szerintem a legnehezebb rész az AS beüzemelése lesz (már ha nulláról indulsz). Akinek viszont van működő környezete, annak a fordítás max 3 perc. -
thon73
tag
Nem használtam még soha az android telefon-részét (csak felhasználóként)
A lányomtól kaptam viszont izgalmas feladatot:
Ha hívás közben másik hívás érkezik, akkor az elutasításra kerül, de a szolgáltató azonnal küld egy sms-t.
Megoldható-e, hogy a hívás közben a telefon figyeli az sms-eket (illetve akár folyamatosan), és amikor egy megadott szöveget tartalmaz az sms (mondjuk a családtag telefonszámát, vagy akár egy kulcsszót), akkor - bármilyen körülmények között (tehát telefonhívás közben is, lehalkítva is stb.) jelezzen?
Tapasztaltaktól kérdezem, hogy ez megoldható-e? Ha nem megoldható; akkor esetleg root alatt megoldható-e?
Ha ugyanis bárhogy megoldható, akkor a konkrét megoldáshoz szívesen elmélyedek a telefon-managerben; de ha nem, akkor most ezt a fejezetet skippelném. (Mert amúgy a telefonom telefon-képességeivel elégedett vagyok.) -
thon73
tag
válasz
laslie92
#3104
üzenetére
Android Studio (ha nincs még fenn, akkor itt van: Android Studio, kell hozza Java JDK az Oracle oldalról.
A main könyvtárat kiteszed valahová.
Android Studio -> File -> Import Project -> Main könyvtár kiválasztva
Ne változtass semmit, csak fogadj el mindent
Android Studio -> Run -> Run 'app'Az .apk itt lesz: main/out/production/main
De ezt azért még ne tedd fel Play-reAmúgy ha szabványos gardle projekt lenne, akkor itt:
app/build/outputs/apkMielőtt az importnak nekilátsz, érdemes legalább olyan szinten megismerkedni az Android Studioval, hogy a saját "Hello Világ" példaprogramját lefordítsa, és el is indítsa (a gépeden vagy az emulátoron). Ha ez megy, akkor a fenti parancsoknak is menni kell.
-
thon73
tag
Szóval nincs semmi automatika erre, hanem "kézzel" kell megcsinálni. Köszi!
((A példakódban van egy finom hiba. Ha nem a létrehozáskor okoz kivételt, akkor nem kerül lezárásra a megnyitott file. A zárást érdemes a finally részbe tenni, és ellenőrizni, hogy writer nem null-e. Egyébként ez szinte soha nem okoz hibát, de azért mégis érdemes tudni.))
-
thon73
tag
Szeretnék egy szöveges file-t mellékelni a program telepítése során.
Ezt hogyan illik csinálni? Beteszem asset-be, és kimásolom, vagy van valami egyszerűbb módszer erre?
A szöveges file-t a felhasználónak látni, esetleg módosítania is kellene, tehát - gondolom - sd területre kellene kerülnie.((A file egyébként egyfajta konfigurációs file, ami a program finomhangolásához szükséges példát tartalmazza. Konkrétan a billentyűzethez annak szabadon beállítható kiosztását.))
-
thon73
tag
válasz
lanszelot
#3076
üzenetére
Csak érdekel: milyen környezetben futtatod az Android Studio-t? Ahhoz, hogy Android alatt el tudj kezdeni tanulni, először kell egy fejlesztőrendszer+egy hozzá csatolt, vele kommunikáló készülék. Ez utóbbi kényszerű esetben lehet virtuális is. Az előbbi célszerűen Android Studio, de pl. ha csak tablet van, akkor lehet AIDE is. A történet ott kezdődik, hogy az egyébként automatikusan létrehozott program lefordul, és kiírja, hogy "hello" vagy valami.
Ha ez megvan, akkor el lehet kezdeni tanulni, akár úgy, hogy komplett projekteket elindítasz. Arra a kérdésre, hogy nem megy, mi a baja? lehetetlen válaszolni. Ezt a programot pl. két év után leporoltam, és mindkét gépemen gond nélkül fut. Ahhoz, hogy neked segíteni tudjak, kellene valami üzenet, logcat kimenet stb. az amúgy kipróbált fejlesztőrendszerből. Androiddal rengeteg gép üzemel, nem lehetek biztos abban, hogy egy ilyen program minden egyes gépen tökéletesen fut, de egy jól működő fejlesztőrendszer legalább emulátoron futattja, vagy hibaüzenetet ad.
Egyébként, ha belenézel az src mappába (ott van maga a program), akkor látni fogod, hogy ez nem "egy lépés". Ha tényleg tanulni akarsz, akkor egy kicsit kisebb lépéssel kezdj. ((Ez a program - csupán a szöveges részek átírásával - átalakítható azzá, amit írtál, ezért mutattam.))
Mivel én is szinte nulláról kezdtem az Androidot, pontosan tudom, hogy ilyenkor minden ismeretlen. De azt is tudom, hogy meg lehet tanulni. A magam részéről szoktam rövid jegyzeteket írni egy-egy kódhoz. Egy barátom kérésére ezeket (egy kicsit kibővítve) közzétettem ITT. Kicsit régi ugyan, meg aztán nem volt később elég időm folytatni, de a kezdő szintű programok szempontjából még nem történt nagy változás. Ha ezeket végigpróbálgatod, akkor a végére el fogod tudni készíteni akár ezt az adatbáziskezelőt is.
Itt a fórumon akkor tudsz elsősorban hasznos segítséget kapni, ha Te is erőteljesen olvasol, tanulsz és dolgozol. Akkor, ha valahol elakadsz, konkrétan tudni fogod, hogy mi az a probléma, amivel nem tudsz megküzdeni. Ha valaki már megküzdött vele (és ez elég valószínű), akkor elmondja az ő megoldását, ami segít. De azt a megoldást is át kell tenned a Te konkrét helyzetedre.
Ezt csak azért írom, mert a korábbi kérdéseid között rengeteg olyan volt, amire a válasz az első google találat első oldalán szerepel. Ettől függetlenül lett válasz, lett program, és még működik is; de ha tényleg tanulni akarsz, akkor a fenti utat is el kell kezdened. Aztán lesz azon az úton még rengeteg kérdés, amire itt választ fogsz kapni.De a konkrét problémához visszakanyarodva:
Kell egy működőképes fejlesztőrendszer, és tudnunk kell, hogy az micsoda. Vagy neked kell tudnod olyan alapokat, hogy hol van benne a logcat lista.
Utána kell a futtatás során generált logcat lista (vagy a fejlesztőrendszer hibaüzenete), és az kb. rögtön meg is fogja mutatni, hogy mi a baj.Ne felejtsd el, hogy ezek úgymond fejlesztés alatt álló programok vagy töredékek, ami soha nem lesz ugyanaz, mintha valamit a Play-ről töltenél le.
-
thon73
tag
válasz
lanszelot
#3073
üzenetére
Üres képernyő!???
Sok hiba lehet benne, de az biztosan nem lehet.
Vagy nem fut egyáltalán, vagy három opciógombnak meg kéne jelennie. Mivel ehhez még semmit se csinál, ezért ennek minden körülmények között látszania kell.
Ha lesz egy kis időm, akkor felrakom az as projektet is. Apropó, a Memento adatbáziskezelőt nem nézted? Nem lenne egyszerűbb egy kész megoldást használni? -
thon73
tag
válasz
lanszelot
#3071
üzenetére
Zip-et kibontod mondjuk temp-be.
AS project betöltésnél leállítod, és feljön a welcome ablak. VAGY File/Import Project és ott importálod. Lesz egy új, AS projekted.
Sajnos kell hozzá a support library.
app felett jobb egérgomb, open module settings (F4), abban a dependencies, abban a jobb zöld +, és a listából: Library dependency majd support-v4 (...) - ez a második egyébként.
Utána mentés, stb. és futtatásra mennie kell. Legalábbis nekem megy.Bocs h. nem töltöttem fel, de azt se lenne könnyebb elmagyarázni. Így meg van referencia, ha valaki régi projektet akar átalakítani.
-
thon73
tag
válasz
lanszelot
#3069
üzenetére
Csak ismétlem magamat: miért nem nézed meg a korábbi hozzászólásomban lévő projektet? zip-ben van egy eclipse project, de az as beolvassa.
Az épp azért készült, hogy egy könnyen bővíthető felület legyen az adatbázishoz. Ezt ugyan nem, de más változatait én mind a mai napig használáom. Az alapszintű adatbázisműveleteket tudja.
Hozzáteszem: egy ilyen program nagyon sok munkát igényel, még a megértése is; a korábbiak alapján sztem. neked egy kicsit egyszerűbbel kéne kezdened. Ettől még ott van, és kipróbálható.
((És nem önreklám miatt írtam, én is csak tanulgatom az androidot, de éppen-pont erre készült.)) -
thon73
tag
válasz
lanszelot
#3066
üzenetére
Csak a szöveges részt (gondolom TextView) is ugyanoda és ugyanúgy tedd be, mint az EditText-et és a Button-t! Akkor scrollozható a többivel együtt.Csak úgy statisztikai érdekességként visszaolvastam, ebben a témában épp egy tucat válaszadó vett részt a kérdező mellett. A magam részéről csak gratulálni tudok a fórumnak!
-
thon73
tag
válasz
lanszelot
#3064
üzenetére
Bocs, én töröltem ki a hivatkozásokat, mert nem akartam egy komplett kódot csinálni az AS-ben.
Csak írd elé, hogy @string/, és működni fog hibaüzenet nélkül. Pont úgy írd be, mint az általad küldött kódban. És a hint_name-nél ugyanúgy.Ez egyébként azt jelenti, hogy a külön definiált stringek közül jelenítesz meg egyet, vagy az ide beírtat jeleníted meg. Az előbbi esetben könnyebb más nyelvre lefordítani - a mi esetünkben sztem. ennek még nem sok jelentősége van.
-
thon73
tag
válasz
lanszelot
#3059
üzenetére
Ezt nézd meg egyszer, (bocs a külső hivatkozásokat kivettem)
<?xml version="1.0" encoding="utf-8"?>
<ScrollView
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
tools:context=".MainActivity"
android:layout_width="match_parent"
android:layout_height="match_parent">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<EditText
android:id="@+id/name"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="hint_name"
android:inputType="textPersonName"
android:maxLength="99"
android:singleLine="true" />
<Button
android:id="@+id/saveButton"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="save" />
</LinearLayout>
</ScrollView>Még van egy olyan, hogy: android:fillViewport="true" a scroll részen belül, de nem tudom, hogy egyetlen soros szövegnél van-e hatása.
A RelativeLayout-nak egyetlen ablaknál (egyetlen child-view-nál) nincs szerepe, az kivehető. És ki kell venni az összes ez-alá, e-fölé dolgot is. Itt uis. van egy scrollview, ami egyetlen "ablakot" (child-view-t) képes kezelni, ami a LinearLayout, ami viszont a benne lévőket csak egymás alatt bemutatja. -
thon73
tag
válasz
lanszelot
#3045
üzenetére
Nolan Lawson CatLog emlékeim szerint, vagy a Play-en keress rá a logcat-ra. ROOT kell hozzá, mert különben nem engedi kiírni más program logcat-ját.
Másik út, ha a programod teszi közzé valahol a hibaüzeneteit. Ez megy Root nélkül is, de jelentősen bővíteni kellene az amúgy sem működő programot.Hol használod az AS-t, ha nincs hozzá PC? Megy linux, úgy tudom mac alatt is.
-
thon73
tag
válasz
lanszelot
#3043
üzenetére
Olyan nincs, hogy nincs hibaüzenet. Ez nem windows.
Olyan sincs, hogy üres az adatbázis, mert ezek a programok az adataikat az adatbázisban tárolják, onnan írják ki. Ha a programban vissza tudod olvasni az adatokat, akkor azok az adatbázisban vannak.
Olyan viszont van, hogy valami valahol hibás. Ez a programozás szépsége: a hibakeresés.
A "Hol a hiba?" kérdésben akkor lehet segíteni, ha valamelyest ismerjük a biztosan jól működő részeket/a valószínűleg hibás részeket/ill. azt, hogy Te meddig jutottál a hibakeresésben. Ezzel együtt is jóval nehezebb, mint egy új kódot elmagyarázni.
Amit tudni kellene:
1. végül milyen fejlesztőrendszert használsz? Android Studio?
2. végül melyik kódot tetted fel? Amit Sianis küldött?Ha saját programot teszel fel, akkor mindenképp ismerned kell a "logcat"-ot. Ez egy olyan napló, amit a programok folyamatosan írnak. Ide kerül minden üzenet, többek között a hibaüzenet is. Telefonon - biztonsági okokból - CSAK roottal férsz hozzá, vagy persze a saját program a saját log üzeneteihez (de azt megintcsak ki kell másolni)
Az Android Studioban, ha jól van feltelepítve, a program futtatása közben meg kell jelenjen egy ablak, amiben futnak az üzenetek. Azt kell szűrni. Alaphelyzetben balra lenn van egy kis Android figura, azzal lehet előkeresni az ablakot.Ha ez megvan, akkor olvasd el a Log osztályt, és máris tudsz magadnak a kódból üzeneteket küldeni. Nem egy nagy történet, és minden adatot ki tudsz írni, látod, hogy mi tűnt el. Ha megvan az a hely, ahol az adat eltűnik, és nem jöttél rá, hogy miért, akkor itt többen is meg tudjuk nézni.
Én magam csak átfutottam Sianis kódját, de egyrészt feltételezem, hogy működő kódot küldött, másrészt nem láttam benne hibát. Ettől még az ördög nem alszik persze.
Mindenesetre, ha nála jó, és nálad nem, akkor még kell egy csomó információ, hogy látni lehessen a különbséget. -
thon73
tag
válasz
lanszelot
#3039
üzenetére
Illetve csak long van. Nem az adatbázisban lesz a baj, hanem valahol átteszi java-ba, ahol viszont int szerepelhet.
Két dolog kellene: maga a hibaüzenet (a logcatban lesz), és a hibás rész kódja.((Egyébként az integert tényleg ki kéne cserélni stringre, mert különben pl a '+'-t sem tudod tárolni. Meg a spaceket se. Meg a bevezető nullákat se.))
-
thon73
tag
válasz
lanszelot
#3029
üzenetére
A lehető legjobb szándéktól vezérelve írom, hogy Neked egy java könyvet kellene először kézbevenned. A saját tapasztalatom szerint az Android-ra éppen nem igaz, amit írtál: vagyis van egy működő kód, és itt-ott belejavítasz. Ezzel lehet módosítani egy-egy feliratot, vagy formát, de további funkciót - amire neked szükséged lenne - nem tudsz hozzáadni. A feladat első része: megváltoztatni az adatbázis mezőket, még megoldható, de az adatok kinyerése már így lehetetlen. Ha Te meg akarod tanulni, annak sincs akadálya, de el kell kezdeni az elején. A konkrét feladathoz szerintem még talán itt is találsz vállalkozó kedvű embert, aki megoldja neked.
"Az external a bővíthető memóriát jelenti, vagy a telefonban lévőt? Nekem nem bővíthető a telefon memóriája."
A rendszer szempontjából az external memória nem az SD-kártyát jelenti, hanem azt, amit nem a rendszer használ. Ez lehet beépített vagy külső (pl. SD), a lényege, hogy jogosult vagy olvasni/írni a tartalmát. Ha ki akarod nyerni az adataidat, akkor az egyik legegyszerűbb megoldás, ha ide írod ki azokat. A rendszer/programok által használt rész "védett", vagyis nincs jogod olvasni, még akkor se, ha Te vagy a telo tulajdonosa. Az Android-on ugyanis minden egyes program külön felhasználót jelent, és pont ugyanannyira nem férhet hozzá egyik program a másik program adataihoz, mint egy felhasználó a másikéhoz egy PC-n. Sőt, még annyira se, mert meg sem engedheti neki.Leegyszerűsítve:
A programok által használt memória: számodra elérhetetlen.
A "külső" (beépített vagy SD): szabadon elérhető, de kell írnod egy külön programrészt, ami ide ment."thon73: Bocsánat, de nem értem amit írtál."
Leegyszerűsítve:
A korábbi link tartalmaz egy komplett programot, amiből egy egyszerű adatbázis (ld. később) kezelhető. Adatok vihetők be, módosíthatóak, sőt el is menthetőek (export) a külső memóriába.
Ez a program épp az, amit kis felületes módosítással átalakíthatsz magadnak. De maga a program sokkal összetettebb, mint az előttem szólók által feltöltött.
Azért azt megjegyezném, hogy a feladat, amit megoldani szeretnél, kb. ilyen összetettségű kódot igényel."A program nyelv egyszerű. Úgy kell olvasni mint az újságot. De újságot írni nem tudok."
A programod egyik felét Te írod, a másik fele az Android rendszer. A Te hasonlatoddal élve olyan, mintha az újságban a hasáb felét letakarnád, és úgy próbálnád elolvasni. Egyszerűen ismerni kell az Android oldalt, mert az annyi mindent készen tol a programok feneke alá. Ezt nem fogod meglátni a kódban, (((legfeljebb a rendszer forráskódjában)))"Nem tudom a szak kifejezéseket."
Ez csak azért baj, mert nem tudunk egy nyelvet beszélni. Senki sem tud minden szakkifejezést, én biztos nem. De egy kis harapással elkezdem, és akkor abban már tudnak segíteni."Nem tudom mi az, hogy adatbázis"
Az adatbázis az szinte egy külön rendszer és külön nyelv az android-on belül. SQLite-nak hívják, így tudsz utánaolvasni, nagyon jó a doksija.
Általánosságban az adatbázis az adatokat táblázatosan tárolja, közelítve: az oszlopok felenek meg az űrlap mezőinek, a sorok egy-egy azonos űrlap adatainak. Mivel a sorok egyformák, ezért nagyon könnyű nagy mennyiségű adattal dolgozni. Úgy képzeld el, mint rengeteg excel dokumentum együttesét. ((Bocsánat, ez csak egy segítő megközelítés, a valóság ennél sokkal többet tud, de valahol itt kell elkezdeni.))
Egyébként a legjobb "adatbázis wiki", és a google segít.", se azt, hogy AIDE"
AIDE Ez egy olyan fejlesztőrendszer, amit a tableten tudsz használni. Vagy akár a telo-n. Ha nincs PC.", SO"
http://stackoverflow.com/ egy olyan oldal, ahol fel lehet tenni konkrét kérdéseket egy problémára, és megoldásokkal válaszolnak. Azért jó, mert 1. már majdnem mindent megkérdeztek 2. nagyrészt meg is válaszoltak 3. témák szerint kereshető. Angolul persze.", Eclipse se semmit."
Az Eclipse volt az Android korábbi fejlesztőrendszere. Az ami ma az Android Studio. Ezt azért kell tudni, mert még majdnem minden példaprogramot Eclipse alá fogsz megtalálni. Szerencsére az Eclipse projekteket az Android Studio be tudja tölteni.Ja, igen. A projektek.
Az android programot ún. projektben készítik el. A projekt könyvtárszerkezete kötött, és rengeteg file-t tartalmaz, amihez a tényleges programnak semmi köze. Ezért nem értetted sztem. a küldött példákat. Neked a projektből csak a kódot kellene elolvasnod, viszont a teljes projekt sokkal könnyebben betölthető egy fejlesztő-rendszerbe (pl. Android Studio), ha kezdő vagy."mert biztos vagyok benne, hogy ezt meg kell változtatnom:
String backupDBPath = DB_NAME;"
Nem, ezt speciel teljesen felesleges megváltoztatnod sztem. Erre csak akkor lenne szükség, ha több adatbázist is tartalmazna a programod.
Ebben erősítsenek vagy cáfoljanak meg a többiek, de én nem találtam olyan módszert, amivel a beépített adatbáziskezelő az adatokat máshol tudta volna kezelni. Vagyis nem lehet megkérni arra a rendszert, hogy a programod adatbázisát tegye olyan helyre, ahol eléred. Az kötötten a megadott könyvtárba kerül. Ki kell másolni onnan."Olvasni, bővíteni tudok, de létrehozni nem!"
Szerintem kezd a java-val, az magyarul is hozzáférhető. Itt elapad a magyar irodalom, jön az angol. De az Android (ld. doksit a saját oldalán), SQLite (szintén saját oldala), és az ezen a fórumon már számtalanszor felsorolt forrásokon elindulva szépen meg lehet ismerni az Android rendszert. Vagy legalábbis azt a szeletét, ami téged érdekel.Bocsánat, hogy kicsit hosszúra sikeredett. Sajnos, nem lehet célom, hogy az egyes kérdésket megvilágítsam, sokkal inkább arra szerettem volna felhívni a figyelmedet, hogy milyen gazdag is ez az egész Android. No persze, ez aránylag sok idő, de nem is kell egyszerre az egészet megemelni. Szerintem nulláról kb. 1 hónap alatt el lehet jutni egy űrlapig, talán még az elmentéséig is. Az adatbáziskezelésre viszont legalább egy fél évet jósolnék nulláról.
És tényleg a legteljesebb jószándékkal írtam, elsősorban azért, mert én is végigcsináltam.
-
thon73
tag
válasz
lanszelot
#3023
üzenetére
Melyik linket a kettő közül? Melyik szakszót? Segítek szívesen.
A lényeg:
A program védett helyeihez CSAK maga a program fér hozzá. Vagy akinek ROOT jogosultsága van. Ilyen jogosultsága lehet egy másik programnak a ROOT-olt telefonon, vagy a PC-n az adb-nek.Ha ilyen nincs, akkor magának a programnak kell "kimásolnia" vagy egy file-ba exportálnia az adatbázis adatait. Ez nem túl egyszerű, de megoldható. Erre példa az az adatbázis, amit korábban küldtem. Az SO linkben pedig a kimásolására van egy program-rész.
Mivel ez egy Eclipse project, PC nélkül nehéz átnézni, meg lefordítani. Én tableten az AIDE-t használom, ami egy az egyben olvassa ezeket a projekteket. Valószínű, egy ekkora projekt már igényelni fogja belőle a fizetős verziót. Amúgy az sok extrát is tartalmaz, sztem. megéri megvenni, ha magán a tableten fogsz programozni.
Szerintem, ha csak egy űrlap és az adatok mentése kell, akkor - még működő adatbáziskezelő mellett is! - egyszerűbb a beírt adatokat rögtön egy file-ba menteni. Ne érezd bántásnak - de szerintem még meg kell ismerd jobban az android rendszert ahhoz, hogy az export-ot biztonsággal el tudd készíteni. Egy fórumnak a keretei nem elgendőek ahhoz, hogy ezt minden részletében kitárgyaljuk. De a kód amit küldtem tartalmazza, és könnyen a Te adataidhoz passzintható.
-
thon73
tag
válasz
lanszelot
#3020
üzenetére
Bocs, de szerintem ez ciki.
Se nem lovagoltam, se nem rugdostam. Pláne nem karöltve másokkal, mert személyesen nem is ismerik itt senkit.
De ez idáig senkit nem akadályozott abban, hogy segítsen nekem - mégpedig rengeteget, amiért nagyon hálás vagyok.
Én is csak segíteni akartam neked egy további kóddal, ami megmutatja, hogy miként tudod előszedni az adataidat.
Ha te azt gondolod, hogy ez rugdosás, akkor csak mérhetetlenül sajnálni tudlak. De bocs, azért is, hogy szólok - ennek végül is se helye, se lényege.Mindenesetre, mint írtam, a file-odat itt keresd:
/data/data/package_name/databases
root vagy adb (vagyis PC) kelleni fog hozzá. Kis útmutató pl. itt.
Örömteli kódolást!
-
thon73
tag
válasz
lanszelot
#3018
üzenetére
Bocs, hogy sokadikként csak most kapcsolódok bele a témába!
Ami off: - kétségtelen, hogy hobbiból - de nekem kb. egy évembe került, amíg C tudásra építve megismertem a javat és az android módszereit. Szerintem, sajnos, az android nem az a rendszer, amit össze lehetne legózni - itt egyszer meg kell érteni a rendszer fifkáját. Activity, Fragmentek stb. És ebben az egész tanulásban a leghosszabb és legnehezebb az adatbázis rész volt. Ezt nem elkeserítésnek szerettem volna, mert én is elég jól átvergődtem rajta, csak - szerintem - erre egy kis időt rá kell szánni.
Amit Te szeretnél: CSAK beírás és tárolás, ahhoz nem kell mindenáron az adatbáziskezelőt használni. Kell néhány EditText, meg egy metódus, ami ezeket elmenti. Igaz, hogy ez fényévekkel kevesebbet tud, mint az adatbáziskezelő, de fényévekkel egyszerűbb megoldani.
Az adatbáziskezelő több hiányossággal küzd.
Egyrészt nincs hozzá "felület" - vagyis az űrlap, azt neked kell elkészíteni (ahogy a példaprogramban is látható)
Másrészt nincs export/import funkció, azt is neked kell megcsinálni. (A db, amit keresel, a "védett" területen van, valahol itt: /data/data/package-name/database. Nem vagyok biztos abban, hogy ez root nélkül könnyen elsőszedhető.)Én nekiálltam egyfajta adatbázis keretrendszert készíteni, ami könnyen átalakítható bármilyen adatbázis/űrlap-ra, ill. az export/import funkciót is tudja. Persze, ez mind változtatást igényel a programon. Magát a projektet már egyszer itt közreadtam: [link] Ez egyébként még Eclipse projekt, de az AS importálja. A korábbi kódhoz képest a "másik véglet", elég összetett program, de semmi varázslás nincs benne. Mondjuk, egy kis android ismeret nem árt hozzá, de a megoldások, jegyzetek alapján el lehet indulni.
Remélem, ez ad még egy kis segítséget a munkádhoz!
-
#2971
thon73
tag
WonderCSabo
#2970
thon73
tag
válasz
WonderCSabo
#2970
üzenetére
Éppen pont ez az, amire gondoltam!! (csak nem tudtam, hogy erre gondolok; meg csak a master/develop szálat fundáltam ki)
Nem állítom, hogy minden git utasítást fejből tudnék, ami ilyen klassz elrendezést csinál - pláne nem az Android Studio alatt -, de ezt már majd kikeresgélem.
Sejtettem, hogy ezt tudnia kell egy ilyen rendszernek. Hála és köszönet! -
#2968
thon73
tag
WonderCSabo
#2967
thon73
tag
válasz
WonderCSabo
#2967
üzenetére
Köszönöm, kipróbálom a válaszokat - vagyis a rengeteg commitot és a brancheket is.
Egyébként dolgozik valamelyikőtök két (vagy több) gépen? Mármint h, saját tapasztalattal ez milyen?
-
thon73
tag
Köszönöm! Ez jó ötlet. És akkor az egyes brancheket kell csak átnéznem, ha a "nagy" változtatásokra vagyok kíváncsi.
Egyébként a "master" szál commit-jait a legvégén ki tudom törölni? Vagy csak amíg nem töltöttek le belőle (hiszen én magam fogom letölteni mindig a másik gépen)? Vagy akkor az "oldal"-branchok sem tudnak hoova kötődni? Vagy ez hülyeség, és úgy kell hagyni, ahogy van?
Bocs, de tényleg csak az alaplépéseket ismerem a gitből, az AS meg absz. erre támaszkodik. Ami amúgy egyáltalán nem baj, mert minden segédeszköz nélkül a kék égen közlekedik az anyag... -
thon73
tag
Bocs, ha nagyon alap és off a kérdésem; viszont ha valaki megvilágítaná, azt nagyon megköszönném.
KÉT Android Studio között szeretném a projektet átmozgatni. (Praktikusan hol az otthoni, hol a munkahelyi gépen dolgozom. Amúgy Eclipse alatt ez simán ment másolással, itt nem.) Addig jutottam, hogy erre a GitHub a legjobb, az alaplépések meg is vannak.
A kérdésem az, hogy miként tudom megtenni, hogy ne keletkezzen millióegy commit? Én csak a főbb lépcsőket szeretném a GitHub-on tartani. Ha mondjuk délelőtt van egy fél órám, este egy másik fél, akkor ezt a kétszer tíz sort pl. nem.
Vagy esetleg van valami egyéb kézenfekvő módszer erre, ami elkerülte a figyelmemet?
Köszönöm! -
#2848
thon73
tag
WonderCSabo
#2847
thon73
tag
válasz
WonderCSabo
#2847
üzenetére
Szóval Oracle JDK 8?
A korábbi gépen fent volt (Eclipse mellett), de egy idő után nem jött a frissítés, és az internetbanking panaszkodott. Azóta OpenJDK volt; de akkor visszatérek.
Köszi!Amúgy "gondom" nekem sincs vele, inkább csak ismeretlen, csak igen komoly erőigénye van. Win7 és Ubuntu 14.04 alatt is használom, a std. virtuális gép egyikben sem talált elég memóriát (hiába 4Gb már kevés...). A saját tabletemmel mondjuk gond nélkül kommunikált.
Még egyet áruljatok el, légy szíves! Minden betű széle kissé lila (Ubuntu alatt), akármit állítok. A rendszerbeállítások hatástalannak tűnnek, ha a Settings-ben kapcsolom ki az antialias-t, akkor meg borzalmasak lesznek a betűk. Csak nekem káprázik a szemem?
-
-
thon73
tag
Nekem is lenne egy-két apró kérdésem Android Studio fanokhoz (lusta voltam, eddig csak épp kipróbáltam, most viszont már nincs is más...RIP Eclipse...)
1. Ubuntu 14.04 alatt 4 Gb aktív memória mellett memóriahiányról panaszkodik (csak a virtuálisgép kezelő). A /tmp könyvtár mondjuk ram-ban van, mert ssd használok. Ezzel van valakinek tapasztalata? Dobjam ki a tmp-t a ssd-re? Vegyek még négy Gb-ot? Volt aki már találkozott ilyennel?
2. Csaknem olvashatatlan az editor rész. Ugyanakkor azt írja, hogy a font megváltoztatása nem javasolt. Ezzel van valakinek tapasztalata? Esetleg egy javaslata valami jó fontra? Hátha nem kell végigprógálgatnom az összeset. (jó, tudom: ízlések és pofonok, de akkor is)
Előre is köszönöm! -
thon73
tag
Ha még nem kezdtél semmi komolyba, nekem van egy-két ötletem...
![;]](//cdn.rios.hu/dl/s/v1.gif)
- atomik billentyűzet (magyar párja a kinesa)
- könyvolvasó szótározórésszel, és a kiírt szavakat ki is kérdezi (önbevallásos módon).
- még jobb, ha az olvasó-rész egyúttal szerkesztő is (ld. a régi WordSmith PalmOS alól)
- még jobb, ha a szerkesztő nem (csak) a formátumokkal, hanem a színekkel is kombinál - ez kis képernyőn előnyösebb (ld. ugyanaza a progi)
- még jobb, ha legalább minimális makrólehetőségekkel is bír
- további - akár univerzálisan használható - makrószöveg kezelő (szintén volt PalmOS alatt, de nem emlékszem a nevére). Ez nem makrónyelv, csak előre beírt szövegeket enged fa-struktúra szerűen pillanatok alatt előkeresni.
- további ötlet szövegszerkesztésre - diktafonnal egybeépített szövegszerkesztő. Még olyan programot sem találtam, ahol rendesen lehetne a felvett audiorészben pozícionálni, nem ám olyat, ami egyszerre vesz fel, és egyszerre enged írni - a kettőt összehangolva. ((Fontos megjegyzés: tablet+Bt keyboard pont olyan gyors, mint a nagygép; a fenti kinesa mellett láttam a 200 feletti sebességet, én is 100 körül írok - tehát lehet szöveget írni tableten, sőt telefonon is.))
- más téma: adatbázis kezelő (leginkább egy front-end), DE ami össze van kötve a naptárral és a címtárral (vagy egyebekkel is). Ilyen sincs egy se.
- futás (sport) közben egy mérés mellett kitartásra is buzdító szöveges (svox) szoftver. Pl: "kitartás, már csak 200 m a hegy teteje!"
- folyadék fogyasztást (kalória stb. akár) "mérő" program. Ezt szaknyelven úgy is hívják (ha a másik oldalt is méri a delikvens): vizelet ürítési napló.Ha ez mind kész,még van egy-két ötletem.
A projektek 0-80%-os készültségi fokban részben meg is vannak; érdeklődés esetén szívesen közkincsé teszem. És ha valaki elkészíti, elsőként fogom letölteni a fizetős változatot!
-
thon73
tag
Bocs a késői válaszért...
Teljes mértékben egyetértek, én is így szoktam megadni.
De most kivételesen egy xml-szerű, human-readable leíró fájlból érkeznek az adatok, többek között a színek is. A számok (tehát a színkódok is) long pontossággal kerülnek feldolgozásra.
Amúgy eddig a részig prímán működik -
thon73
tag
Többek között ez bizonytalanított el: saturatedCast
Tehát vannak olyan algoritmusok, ahol az előjelbit "elveszik".De a válaszok alapján primitív típusokkal nyugodtan dolgozhatok. Köszönöm!
((tovább olvasva rájöttem, hogy a primitivek közötti levágást konverziónak, ezt meg castnak nevezi az irodalom)) -
thon73
tag
Hát ez az. De az int ugye signed int. Ezért nem mindegy, hogy a long->int veszteséges átalakításnál mi történik. Ha csak eldobja a felső két byte-ot, akkor minden ok. Ha azonban az átalakítás Integer.MAX_VALUE és MIN_VALUE között történik, akkor az algoritmustól függően a színek (kevésbé átlátszó) felét elveszíthetem.
Eddig úgy tűnik, hogy a primitív típusoknál az előbbi történik. Abban nem voltam biztos, hogy ez mennyire biztosan van így.
-
thon73
tag
válasz
Superhun
#2761
üzenetére
Tehát minden esetben csak levágja a long felső két byte-ját, és az alsó kettő lesz az int, mintha nem is lennének negatív számok (mármint a longban). Vagyis pl. a -2L az nem -2 lesz int-ben, ha megfordítjuk a kérdést.
Köszi, ez nagyon fontos, mert így 5 betűvel - (int) - megoldottam az egész átalakítás kérdést. A legtöbb helyen (pl. sqlite) az Androidban uis. long szerepel. És a Color-ban ehhez nincs semmi segítség; bár a fentiek alapján nem is kell.
Köszönöm! -
thon73
tag
Egy apróságot meg tudnátok nekem erősíteni?
Egy color értéket szeretnék int-be tenni, ami ugye unsigned. Viszont long értékként kapom meg.long colorInLong = 0xFFFFFFFF;
int color = (int) colorInLong;Ez a konverzió minden esetben jó lesz? Vagy miként illik ezt elvégezni? (A long valid color értéket tartalmaz.) Köszi!
-
thon73
tag
Sőt, továbbmegyek. Valószínűleg inkább egy Loader-re lenne szükségem, ami a Service inicializálását elvégzi. Találtam egy ilyet Can you use a LoaderManager from a Service?
Van ezzel valakinek tapasztalata? Akár az AsyncTask, akár a Loader nagy segítség lenne... Jelenleg van egy 4-5 mp-es előkészítési idő, amit a rendszer már nem enged meg. ((De csak egyetlen egyszer, amikor a service-t először elindítom.)) Köszönöm! -
thon73
tag
Készítettem egy InputMethodService-t. DE az inicializálás (ami csak akkor történik meg, amikor ezt a billentyűzetet kiválasztjuk) rel. hosszú idő.
Hogyan lehet egy ilyen service-ből időigényes feladatot végrehajtani? AsyncTask-kal? Az indítható service alól? Előre is köszönöm! -
thon73
tag
Sziasztok!
PreferenceActivity-n belül csinált már valaki olyan Preference-t, ami 'int' értéket ment el? Maga a Preference forráskód minden típusra (intre floatra stb.) tartalmaz egy-egy metódust, de bevitelre csak az EditTextPreference osztályt találtam, ami csak String-et tárol.
Köszönöm, ha van egy link vagy útmutató! -
thon73
tag
Viszont működik
Ez nem a 4-8 bites konverzió. Ez a "függvény" azt a 16 (4 biten) 32 (5 biten) vagy 64 (6 biten) alapszínt választja ki, ami a setPixel()-nak átadva, majd a getPixel-től visszakérve önmaga marad. Ez uis. csak ezekre a színekre igaz, az összes többi szín ezek valamelyikére fog alakulni (lévén több színt ekkora helyen nem lehet ábrázolni.)
Ha valahogy meg tudnám szerezni rgb_565 formátumban a színadatokat, akkor erre semmi szükség nem lenne. -
thon73
tag
Úgy tűnik, mindig túlságosan elvarázsolt problémákkal találkozom...
Hátha mégis valaki beleütközik ugyanebbe, megválaszolom magamnak.
Megdöbbentő módon az Android valójában csak kétféle módon tudja a bitmap színeket kezelni: ARGB_8888 és RGB_565 kódolással. (Létezik, de nem javasolt az ARGB_4444. Létezik, de nem működik a getPixel() metódussal az ALPHA_8)
(((Nekem még nem okozott problémát, de a megjelenítés ált. RGB_565-tel történik, vagyis valahol az ARGB_8888 mindig átalakításra kerül.)))Egy "térképet" szerettem volna megrajzolni (ezért nem jó egy tömb) 512 különböző színnel. A szinek nem lényegesek, az viszont igen, hogy pont azt a színt "vegyem ki", amit a képbe belerajzoltam. A korlátozott hely miatt arra gondoltam, hogy valamelyik helytakarékosabb kódolást fogom választani.
Ez viszont egyáltalán nem egyszerű, mert a getPixel által visszaadott alapszínek(R,G,B) mindig 256 árnyalat terjedelműek lesznek - nem pedig a kódolással azonosak. Továbbra sem találtam metódust a "raw" színérték megszerzésére.ARGB_8888 alatt persze minden tökéletesen működik, hiszen itt minden alapszín 256 árnyalattal kódolt. Ehhez azonban dupla hely kell...
ARGB_4444 alatt az alapszinek 4 bit terjedelműek, vagyis 16 árnyalatuk van. Ha azonos színt akarunk visszaszerezni, akkor a szinek 4 bites értékét dupláznunk kell: 2->22 8->88 c->cc (hexában). Az ilyen, hexában azonos számjegyekkel bíró színeket megadva (pont 16 van) ugyanazt a színértéket kapjuk a getPixellel, mint amivel rajzoltunk.
Persze, semmi nem elég, nekem az RGB_565 kódolású rajzból kellett azonos színeket kiszednem. A source kód a dithering miatt elég elvarázsolt, nehéz kideríteni, hogy pontosan hogyan kódol, ill. sokkal összetettebben kódol, mint amire ehhez a feladathoz szükség van. Matematikailag a következő összefüggést találtam:
5 bites szinek - R és B, 32 árnyalat: setPixel( árnyalat * 8 + 5 ) beállítás után a getPixel() / 8 visszaadja az eredeti árnyalatot.
6 bites szín - G, 64 árnyalat: setPixel( árnyalat * 4 + 2 ) beállítás után a getPixel() / 4 szintén az eredeti árnyalatot adja vissza. ((Megjegyzem, az első 32 árnyalatra az előző összefüggés is működik))Bocs, ha valakit untattam ezzel, de nekem hosszas fejtörést okozott, hogy megtaláljam azokat a színeket, amiket beállítva ugyanazt az értéket kapom vissza. Megjegyzem, hogy több különböző alapszín árnyalatot ezek a kódolások nem is tudnak tárolni, az összes többi "bemeneti" szín ezen árnyalatok valamelyikére redukálódik.
Még annyit tennék hozzá, hogy amennyi info-t találtam, az Android ebben is elég egyedi. Vannak 565-888 színkódolás átalakítások, de mintha az android egyiket sem követné, hanem valami saját algoritmusa lenne.
-
thon73
tag
Ha készítek egy RGB_565 kódolású bitmap-et, akkor van lehetőségem a "nyers", 16 bites color információ kinyerésére/beállítására? (mondjuk egy ponton) Vagy hogyan módosul a setPixel/getPixel color értéke (ami elvileg ARGB_8888)? Az R-G-B byte-ok utols 5 (ill. G esetén 6) bitje kerül felhasználásra? Vagy arányosan tömöríti a színeket?
Sehol nem találtam erre útmutatást, és amit kipróbáltam, abban sem értem, hogy mi történik. Hogyan lehet az ARGB_8888 és az RGB_565 értéket egymásba konvertálni? (Tegyük fel, hogy az "elveszett" színek nem számítanak, csak az átkonvertálhatóak)
Előre is hálásan köszönöm!
-
thon73
tag
Van valakinek tapasztalata a View onMeasure() metódusában?
<FrameLayout android:id="@android:id/inputArea"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:visibility="gone">
</FrameLayout>Ebbe a FrameLayout-ba helyezek egy custom View-t, aminek semmilyen Layout paramétert nem adok meg. Ilyenkor - gondolom a Frame Layout miatt - teljes képernyőszélesség:MeasureSpec.EXACTLY és teljes képernyőmagasság:MeasureSpec.AT_MOST értékekeket kapok az onMeasure paramétereiként.
Hiába írom be a kép létrehozásánál pl. ezt:
boardView = new BoardView( this );
boardView.setLayoutParams( new ViewGroup.LayoutParams( 200, 200 ) );NEM 200x200-as kérést, hanem az előbbi értékeket kapom. (Akkor is, ha ViewGroup helyett FrameLayout-ot adok meg, hiszen az csak leszármazottja.)
Ezzel szemben, ha készítek egy res/layout xml-t, és ugyanezt a custom View-t abból (inflate-tel) készítem el, akkor figyelembe veszi a View-hez beírt layout paramétereket.
Két kérdésem van:
- Mit rontok el a programkódnál megadott paramétereknél, ami miatt nem veszi azokat figyelembe?
- Mikor vehetem biztosra, hogy a megkapott mérési értékek a teljes képernyő méretét fogják tartalmazni - már amennyiben semmilyen layout paramétert nem adok meg? (Az oké, hogy AT_MOST, meg EXACTLY jelzőkkel)Amúgy a kép arányaihoz akarom passzintani a View-t, ami rendben is működik - ha a második kérdésre "mindig" a válasz. A másik részt meg csak simán nem értem - eredetileg ezzel akartam volna biztosítani a második kérdést...
-
thon73
tag
Ha esetleg van valakinek tapasztalata ilyesmivel - a doksi több helyen is ezt írja a send...KeyEvent() metódusoknál:
"Note that it's discouraged to send such key events in normal operation; this is mainly for use with TYPE_NULL type text fields, or for non-rich input methods. A reasonably capable software input method should use the commitText(CharSequence, int) family of methods to send text to an application, rather than sending key events."
Ebben az esetben hogyan tudok olyasmiket visszaküldeni mint pl. fel-le nyilak? Mert a közvetlen környezetemet még csak-csak elszerkesztgetem, bár egy backspace, delete, jobbra-balra megoldása sem túl egyszerű.A másik teljesen független kérdésem, hogy egy custom View szeretné megváltoztatni a saját méretét (vagyis onMeasure-ben EXACTLY esetén más értéket adna vissza), akkor milyen utasítást kell kiadnom? requestLayout? invalidate? Köszönöm!
-
thon73
tag
Pontosan. Miután kicsontoztam a softkeyboard példaprogramot, már nem is volt annyira bonyolult, mint amennyire tartottam tőle! A lényegi részek megvannak, remélem a többivel sem akadok el. Még kell rajta filozofálni egy kicsit, mert 3 inches képernyőn azért nem a tökély 
De tableten note-stylussal meg ujjal is nagyon jó. -
thon73
tag
Hm. Ez egy soft-keyboard lesz, a bitmap a layout, vagy nevezhetjük háttérnek is. Az onDraw semmi mást nem tesz, csak kirakja ezt a bitmapet, meg egy karikát ahol a user ujja van. Esetleg nyomvonalat. Nem hiszem, hogy nyernék a worker-threaddel, mert a képet ígyis, úgyis újra ki kellene raknia. Ezért hagytam ezt a megoldást. Mindenesetre elég jól megy, de lehet h. még lehetne optimalizálni...
-
thon73
tag
Azt hiszem megoldottam, bár lehet, h. nem ez a legoptimálisabb. A grafikában nem vagyok otthon. (A nem ide tartozó részek hiányoznak a kódból.)
private Bitmap skin;
private Bitmap skinscaled;
private void init()
{
skin = BitmapFactory.decodeResource(getResources(),
R.drawable.portrait);
}
protected void onSizeChanged (int w, int h, int oldw, int oldh)
{
skinscaled = Bitmap.createScaledBitmap( skin, w, h, false);
}
protected void onDraw(Canvas canvas)
{
canvas.drawBitmap( skinscaled, 0f, 0f, null);
}Egy további kérdés még felmerült bennem: az onDraw-ban megkapott canvas-szal csak az onDraw-ban rajzolhatok (invalidate után mindent újra), vagy máshol is rajzolhatok rá, olyat, amit nem kell letörölni a következő rajz előtt? (Az ujj húzásának az útját mutatja; felemelésig)
-
thon73
tag
Bocsánat, még egy kérdés az optimalizálásról.
Van egy - mondjuk 1200x800 pixeles képem, amit az onDraw helyez bele a Viewbe így:
canvas.drawBitmap(skin, null, dst, null);
(Rect dst értékét az onSizeChanged-ben szedem össze, gyakorlatilag a View mérete, a bitmap dekódolása, közelítő átméretezése meg a konstruktorokban van.)Kérdés:
Mivel rajzolok a bitmap felszínén (egy pont követi az ujjamat), ez a drawBitmap() minden alkalommal lefut. És minden alkalommal ismételten átméretezi a bitmap-et. (Hol 798, hol 356 stb a View mérete, pl. ahogy forgatom a készüléket.)Ezt kell-e v. lehet-e optimalizálni? Az inSampleSize segítségével már megközelítőleg ekkora képet csináltam, de nem pontosan ekkorát. Vagy ez nem akkora terhelés? Végül is elég gyorsan fut...
-
thon73
tag
Meg tudnátok mondani, hol találok "matrix transformation" témában egyszerű magyarázatot?
Arra lenne szükségem, hogy egy nagyméretű bitmap-et (lehet a resource-k között) átalakítsak éppen akkorára, mint amekkora a custom View. Mivel az onDraw (egyebek mellett) ezt folyamatosan újra megjeleníti - gondolom - célszerű lenne egy éppen megfelelő méretet tárolni belőle átmenetileg.
Addig jutottam, hogy ezt a matrix segítségével lehet megtenni, de sem a hogyant, sem a miértet nem értem.
-
thon73
tag
Kérdésem:
A ListView-nál azt írja a tudomány, hogy Loader töltse be a háttérszálon, és Filter szűrje, szintén háttérszálon.
Ha szeretnék beletenni egy sort-ot (mégpedig úgy, hogy menet közben a sort feltételt a felhasználó megváltoztathassa), akkor azt hova érdemes/kell tenni?Ha a Loader-be teszem, akkor az egész lassú betöltést megismétli, amikor csak a sorrendet akarom módosítani.
Ha a Filterbe teszem, akkor minden szűrés elején egy csomó ideig sorrendbe rak.
Ha csak az adapterbe teszem, akkor meg nem a háttérszálon történik. ((Ez önmagában nem baj, de lehet, hogy lassúbb, mint a filter))
Van erre nézve valakinek tapasztalata?
Készítsek egy külön asynctaskot? (Egyetlen sorért!?) Egy második Filter osztályt, ami rendez és nem szűr? Broadcastal kérjem meg a LOader-t, hogy ne töltsön csak rendezzen? Nekem egyik sem szimpatikus.
Előre is köszI! -
thon73
tag
Bocs, csak most csatlakoztam bele a történetbe.
Én ugyanezzel a problémával szembesültem, azzal kiegészítve, hogy nem csak az ékezetek, hanem néhány írásjel átalakítására is szükségem volt. Végül úgy oldottam meg, hogy készítettem egy kb 300 elemű tömböt. Az indexet az unicode kód adta, az elem értéke pedig visszaadta, hogy milyen ékezettelen karakternek kell ezt tekinteni. A tömb mérete felett csak nagyon elvarázsolt karakterek vannak (vagyis az európai nyelvekben nem használatosak), így ott mindig az "ugord át" jelet adta vissza.
((Nagyon zárójelben jegyzem meg, hogy ezt továbbgondolva ezzel az egy táblázattal sikerült a lényeges nyelveken rendezni a kifejezéseket, ill. keresni is ékezetlenített módon.))
Persze ez is csak egy módszer a sok közül, de gyors, tömör és hasznos volt. Nem a végleges változat, de ITT megtaláltam, amit írtam róla korábban.A targettel kapcsolatban annyit fűznék hozzá (bár fentebb elhangzott), hogy ebbe a hibába én is beleestem, mert 2.36 alá írtam a programokat, és a régi sdk-val fordítottam.
Valóban az a követendő, hogy a leges-legújabb sdk legyen fent, és ez szerepeljen a project.properties-ben is. (És amivel szintén voltak hm. gondjaim: a support library-t is illik ezzel együtt frissíteni a projektben). A minimalis és a target (a manifestben) ettől függetlenül bármire beállítható. (Én is többnyire API8/API10 kombóra fordítok, de (((elvileg))) a legutoljára letöltött sdk-val.) -
thon73
tag
Bocsánat, hogy a sok magas szintű fejlesztés mellett egy nagyon kezdő kérdéssel állok elő.
A multithread-ek világában próbálok elmélyedni. Tudna valaki egy olyan kódot/linket adni, ahol specifikusan Android-on a happens-before eseményt tudnám tanulmányozni; vagyis amivel el tudom érni, hogy a thread-ek biztosan megkeveredjenek?
Specifikusan egy olyan ötlet kellene, hogy a thread a saját cache-ében tárolja el a globális változómat, és nemigen tudom, hogyan lehetne ezt kikényszeríteni.
Nem a helyes megoldásra van szükségem (arról rengeteg okos ötlet van), hanem magát a hibajelenséget szeretném látni.
Előre is köszönöm! -
thon73
tag
Thx. Mindkettőtöknek!
Shared prefsre én is gondoltam, de eredetileg függetleníteni akartam a context-től. Végül is nem gond; úgy oldottam meg, hogy a könyvtár alapból beállított adatokkal már működik; ha meg változtatni akarok rajta futás közben, akkor ahhoz kell context is.
Amúgy ha a process eltűnik, akkor az Application is eltűnik, nem? Vagyis mindent újra kell indítani. Vagyis ideális alternatíva lenne globális adatok elhelyezésére (speciel most nekem nem erre kell, csak belső adatok tárolására voltam kíváncsi). Ennek ellenére azt olvastam, hogy nem ajánlott elrendezés, mert nehéz tesztelni...
És csak a teljesség kedvéért: ha csinálok egy singletont, ami valójában egy példány, csak saját magára való hivatkozást tárol, akkor az hogy létezik, hogy az Activity-vel együtt eltűnik? (És nem az Applicationnel. Vagyis memória kevés, háttérben Activity bezár, Application marad, de a singleton is eltűnik.) Ezt egyébként több helyen olvastam, és már én is tapasztaltam. Annak nem kéne a process végéig megmaradni?? Vagy az önhivatkozás máshogy számítana?? Ennek a kérdésnek ugyan már semmi köze az eredeti problémához, csak érdekel...
-
thon73
tag
Van egy static metódusokat tartalmazó osztályom. Ez az osztály néhány belső adatot szintén static osztályváltozókban tárol. Amit a konfigurációs változások és singletonok kapcsán olvastam, kissé elbizonytalnított.
- A program újraindításakor (konfigurációs változás miatt) vajon megmaradnak-e ezek az adatok(gondolom ez a helyzet), vagy új osztály (új adatokkal keletkezik?) Hogyan lehet kikényszeríteni, hogy az osztály újrainicializálja az adatait?
- Van-e arra esély, hogy a program újraindítás nélkül (pl. ha csak háttérbe kerül) egyszer csak bezárja ezt az osztályt, aztán újraindítja újrainicializált adatokkal?
Nekem az kellene, hogy minden indítás üres adatokat eredményezzen, viszont azok a program újraindulásáig megmaradjanak. És a hab a tortán: lehetőleg NE legyen köze az Activity-hez, context-hez. (Uis. egy független részben szerepelnek a metódushívások.) Vajon ez megoldható?
-
thon73
tag
válasz
eastsider
#2168
üzenetére
Bocs, de nem egyszerűbb felrakni újra ez egész csomagot? Ez az "egyetemen beállított, hazavitt" dolog szerintem tartalmaz egy-két buktatót. Az eredeti csomag letöltve/felrakva teljesen üzemkész; (a JavaJDK-t, meg a drivert amúgy sem az kezeli.) Csak úgy kérdezem.
Bocs eastsider, nem frissítettem,mielőtt válaszoltam, de a lényeg: az jó megoldás amit írsz!
-
thon73
tag
válasz
eastsider
#2162
üzenetére
Sztem. az s az egy String. Ha egy objektomra vagy kíváncsi egy listában, akkor az egészben keresd! Most épp egy substring-et keresel!
Sztem. az egészet ráadásul arraylistté is kell alakítani, ahhoz, hogy működjön:
Arrays.asList(aperture_array).indexOf( aperture ); - feltéve, h. aperture egy string. -
#2160
thon73
tag
WonderCSabo
#2159
thon73
tag
válasz
WonderCSabo
#2159
üzenetére
Ja, akkor mégiscsak én értettem félre. Nem csoda, hogy nem sikerült megkeverni a gépet... Viszont akkor jól fog működni amit írtam! (((Ezt az egyszerű log-ot csak úgy hirtelen készítettem, amikor a még-nem-rootolt tab nem volt hajlandó kiírni a rám vonatkozó system log-ot (AIDE-t használtam külföldön, net nemigen volt). És a feladatát tökéletesen el is látta. Később univerzálissá - pontosabban thread-safe-é akartam tenni, csak megzavart, amiket olvastam: eredetileg is thread-safe volt
)))(((Most meg van egy nagy adathalmazom, amit a program szépen feldolgoz. Arra gondoltam, hogy nem fogom minden csip-csup hibáért leállítani az egész folyamatot, hanem szépen log-olja a hibákat, és csak a végén mondja meg, volt-e hibás (nem importálható) adat. Erre viszont pont kéznél volt ez - a logtól független - secunder log. Egyébként ez tök jól működik, abban nem voltam biztos, hogy minden körülmény között fogja-e ezt produkálni...)))
Hálás köszönet, nem rongálom tovább a kiírást...
-
thon73
tag
Tapasztalt guruktól szeretnék segítséget kérni!
Korábban azt mondtátok, (és ezzel a doksi is, meg még én is egyetértünk), hogy egy KÖZÖS file írása több file-ból és több thread-ból veszélyes, mert a kiírt tartalom összekeveredik.Tesztelés szempontjából megpróbáltam ezt elérni, (mármint, hogy a program rossz legyen, és keveredjenek az adatok), és LEHETETLEN! Minden ellenőrzést kivettem, és már nem is Channel-en keresztül próbálkozom (ami elvileg thread safe). Két, teljesen más package nevű program van, mindkettő több szálat futtat. Az adatok mindkét program minden száljáról megérkeznek.
//Nyitás közös
OutputStreamWriter stream = null;
File file = new File( Environment.getExternalStorageDirectory(), "ThreadCheck.log");
stream = new OutputStreamWriter( new FileOutputStream(file, true) );
//Több ilyen thread van:
new Thread(new Runnable() {
public void run() {
try {
for (int n = 1; n < 8000; n++) {
stream.append( "Egyes" );
}
}
catch (Exception e) {
Log.e("THREAD", e.toString());
}
}
} ).start();A kész file az "Egyes", "Kettes" stb. szavakat egyben, épen tartalmazza.
Én értettem félre valamit, vagy ez egy Android tulajdonság, amiben meg lehet bízni?
Vagy hogyan tudom a programot "elrontani", és honnan tudhatom meg az ellenkezőjét: hogy minden körülmény között jól fog működni?Előre is köszönöm!
(((Egy "log" szerű programrészre lenne szükségem: több file, esetleg több thread is ír ugyanabba a file-ba üzeneteket. Az üzenetek sorrendje stb. nem lényeges, csak az, hogy egy üzenet egyben maradjon. Ez ugye megvalósul, csak abban nem vagyok biztos, hogy ez így biztonságosan jó-e.)))
-
#2153
thon73
tag
kemkriszt98
#2144
thon73
tag
válasz
kemkriszt98
#2144
üzenetére
MIt jelent, hogy "teljesen rossz helyen"? Rossz kezdőponton v. csak rossz irányban/méretben? Én első körben leellenőrizném az összes értéket log-ban, aztán kiderül...
-
thon73
tag
Ha számolni kell, akkor még jobb - durván - számtani sorként tárolni ezeket (Durván: mindig feleződik, de csak kb.) Kis nehézséget jelent a köztes értékek tárolása, mert pl. létezett 1/100 és 1/50 is; nekem pl. a Momettán az volt (1956-ban gyártott készülékről beszélünk)
Mindenesetre az egész érték jelentheti a sorban elfoglalt helyet, azzal (amennyire emlékszem) számolni is lehet. Egy emelés megfelel egy blendének, ugye? Egyúttal megadja a String-Resource érték indexét is.
Bocs, hogy belekontárkodom, de a dolgozat szempontjából nem lenne egy jó ötlet összehasonlítani a kül. tárolási módok előnyeit és hátrányait? Ez uis. egy komoly számítástechnikai kérdés, a többi viszont csak technológia. Pontosabban, hogy mennyire tudsz elevezni az Android hibái és korlátai között. -
thon73
tag
válasz
eastsider
#2133
üzenetére
Én egészként. Mondjuk első két byte egész mp, másik két byte törtrész nevezője, és még mindig van négy byte. Vagy + = egész, - = törtrész, és akkor egy bit jelzi a formát. Vagy: egy byte típus (óra, perc, mp, tört), többi az érték. Vagy memóriapazarló módon: egy mező: érték, másik mező: típus.
De én az elsőket választanám, és csinálnék hozzá egy osztályt. -
thon73
tag
válasz
eastsider
#2128
üzenetére
Elvileg már vannak nested-fragment-ek, de support library-val nekem nem ment. Amikor elfordítottam a készüléket pontosan ellenkező sorrendben jelentek meg a Fragmentek - az utolsó dialog volt legalul. ((Ez egyébként bug-ok között szerepel, akkor meg is találtam. Nem tudom, hogy későbbi változatokban javították-e, ott sokan panaszkodtak, hogy nem.))
Én minden eredményt visszaadnék az Activity szintjére és onnan nyitnék meg - akár a még megtartott Dialog tetején - egy új fragmentet. Kicsit játszani kell az adatok ide-oda utaztatásával, de legalább tökéletesen működik.
A másik lehetőség, hogy az egyszerűbb dialogusoknál nem használsz fragmentet. Sztem. annak az egyetlen előnye, hogy újraindításnál megmarad, ez meg nem. -
thon73
tag
No, úgy tűnik, sikeresen beletenyereltem valamibe, ami messze meghaladja a tudományom. Ami megnyugtat: nem csak az enyémet. Tanulás céljából ajánlom a következő cikket: [link]; szerencse h. az említett professzor volt olyan kedves, és a pórnépnak is csinált biztonságos osztályokat...
Kibogoztam az ArrayAdapter source-kódját is. A konstruktorban megadhatjuk a felhasználni kívánt ArrayList-et, melyet = jellel tárol a belső változóban.
Ezt követően a Filter() rész pont azt csinálja, amit én: lock-olja a belső változó hozzáférését, és végigolvassa a tömböt (pontosabban átmásolja egy másikba). Ez azonban NEM szinkronizált cselekedet, uis. időközben egy másik programrész (akár UI szálon,mert a Filter worker-szálon van!) módosíthatja az eredeti tömböt. Vagy összeomlik, vagy exception-t kapunk. A saját változatomban (belassítottam a filtert) sikerült is a hibát produkálni.
Ált. persze nem lesz hiba, egyszerűen azért, mert a Filter (ha egyáltalán használjuk), sokkal gyorsabban lefut, semmint változna közben a tömb. De ha a Filter lassul - akkor máris előjöhet a hiba, még a legegyszerűbb listában is. Az én problémám nyilván szélsőséges (túl nagy a lista), és valójában a filtert nem is akartam használni (pont a lassúsága miatt), de a logikai hiba az akkor is logikai hiba.
Elvi megoldást úgy találtam a magam számára, hogy készítek egy ArrayList leszármazottat, amit a Loader fel tud tölteni, távolról változtatható - de csak akkor, ha a Filter nem állítja le a működését. Pl. úgy, hogy a filter teljesen más metódussal vesz ki elemeket; ha a tömb változik, akkor ez a lehetőség lezárul, úgyis megváltozott a szűrni kívánt anyag.
Gondoltam, megosztom a gondolataimat, hátha mást is érdekel ez a kérdés. De, mint fent írtam, ez kicsit több, mint amit biztonságosan átlátok, így aztán ha hülyeséget gondolk, kérlek, javítsatok!
-
thon73
tag
Egy kis olvasás után jobban meg tudom fogalmazni a kérdésem:
A BaseAdapter legnagyobb része UI szálon fut, tehát használhat a program többi részével közösen egy olyan ArrayList-et, amit a többi rész is csak UI szálon módosít.
A BaseAdapter egyúttal Filterable is lett, vagyis tartalmaz egy Filter.performFiltering metódust, ami viszont egy Worker thread-en dolgozik, ÉS olvassa a fenti ArrayList adatokat.
Én úgy látom, hogy csak a Filter.performFiltering területén kell védenem ezt a közös ArrayList-et a módosítástól.
Mi lenne erre a leghatékonyabb módszer? ((Vehetünk két helyzetet is: kis méretű és extra nagy méretű listák, ahol a filtering is sokáig tarthat))
Vagy valamit teljesen rosszul értek?Természetesen az osztálynevek a felmenőket jelentik, mindegyikből van saját.
-
thon73
tag
Bocs, van egy elég kezdő kérdésem, de nem nagyon értem...
Egy BaseAdapter alapú Adapter külső adatokra hivatkozik. Amit private-ként tárol, azok nem maguk aza adatok, hanem csak egy mutató a távoli adatokra. (ListArray mérete kb. 200 ezer elem)
Ha valaki megváltoztatja az adatokat (mármint a tömb marad, csak hozzáad v. elvesz), akkor a notifyDatasetChanged()-del tájékoztat arról, hogy újra kell rajzolni a ListView-t. Eddig nincs is talán gond.
DE!
Ha a háttérben elindul a Filter, akkor az a távoli adatokból végez egy leválogatást. Hogyan tudom megakadályozni, hogy a leválogatás közben kívülről megváltozzanak az adatok?
Jól sejtem, hogy a synchronized( lock ) ((ahol lock egy sima private osztály-objekt)) csak a saját osztály által elkövetett változtatásoktól véd?Vagy hogyan illik ezt megcsinálni? A gyári ArrayAdapter csinál egy komplett másolatot az összes adatról, mielőtt elkezdené leválogatni. Ez nem túl idő- és munkaigényes?
Vagy mi a jó út erre? Előre is köszönöm!
-
thon73
tag
válasz
eastsider
#2116
üzenetére
Jah, pont ezt. De akkor rendben is vagy: 68 Kb.
Valószínűleg valahol tárolja a képeket. Lehet h. már várnak az eltakarításra, gondolom azt is beleszámolja. Azt kell végiggondolnod, hogy a betöltött képekkel mit csinálsz? Ha mindig újratöltöd, akkor a lista minden soránál tölteni meg számolni fog.
Jelenleg a Loader semmit se csinál a képekkel, csak a szöveget tölti be. Az adapter tölt képet.
Az elvileg megoldható, hogy a loader betöltse a képet, de nem javasolnám, mert macera.
Inkább azt kéne megoldani, hogy az adapter egy hátsó szálon töltse a képet. Pl.: Adapternek szüksége van egy képre, akkor azt a hátsó szál lekicsinyíti, és menti egy cache-be. Ha ott megvan, akkor persze adapter csak beolvassa. Hogy miként lehet a konkrét listaelemet frissíteni, ha kész a töltés, azt még nem látom át. De ez csak egy hirtelen ötlet volt - mindenesetre valahogy szét kell választani a csigalassú részeket, meg eldönteni a memória vs. idő kérdést. Alighanem ehhez most papír meg ceruza kell inkább, s csak aztán a kódírás... ha szabad javasolnom.
Bocs, nem szóltam, megvan!
![;]](http://cdn.rios.hu/dl/s/v1.gif)
De tableten note-stylussal meg ujjal is nagyon jó.
Köszönöm! Ez lényegesen egyszerűbb!
Új hozzászólás Aktív témák
Hirdetés
- Dell Latitude 7410 Strapabíró Ütésálló Profi Ultrabook Laptop 14" -80% i7-10610U 16/512 FHD IPS MATT
- Eladó Lian Li O11D MINI-X gépház
- Lenovo ThinkPad P17 Tervező Vágó Laptop -50% 17,3" i7-10750H 32/512 QUADRO T1000 4GB
- FSP DAGGER PRO ATX3.0(PCIe5.0) 850W Sfx tápegység
- Eladó PNY GeForce RTX 4070 Ti SUPER 16GB OC XLR8
- ÁRGARANCIA!Épített KomPhone i5 10600KF 16/32/64GB RAM RTX 3050 6GB GAMER PC termékbeszámítással
- FSP RAIDER S 750W 80 PLUS Silver táp
- Bomba ár! HP ProBook 450 G6 - i7-8GEN I 16GB I 256SSD I HDMI I 15,6" FHD I Cam I W10 I Gari!
- ÁRGARANCIA!Épített KomPhone Ryzen 9 5900X 16/32/64GB RAM RTX 5070 12GB GAMER PC termékbeszámítással
- Telefon felvásárlás!! iPhone 14/iPhone 14 Plus/iPhone 14 Pro/iPhone 14 Pro Max
Állásajánlatok
Cég: PCMENTOR SZERVIZ KFT.
Város: Budapest
Cég: Promenade Publishing House Kft.
Város: Budapest