Programmi di esempio ??

**mimmog** · 07-10-10 22:13

Originariamente inviato da dhalia

mmmm bene mi scoraggi così visto che arrivo tra qualche pagina al 4 ahaha

no dai sinceramente penso che in 5 giorni non sia male aver digerito abbastanza bene i primi 3...
in caso avrò una spalla su cui pianger se mi areno anche io hehe

Oh mamma!!! fammi sapere il difficile comincia dal cap 4 in poi !!!!

**dhalia** · 07-10-10 22:22

Originariamente inviato da mimmog

Oh mamma!!! fammi sapere il difficile comincia dal cap 4 in poi !!!!

Certo! anzì guarda diamoci appuntamento in qualche post tra un po' di tempo così vediamo come procedon i progressi di entrambi ihih
(tra un po' ti darò un po' di vantaggio visto che dovrò mettermi sotto per l'esame di statistica/probabilità, software engineering e db)

**Cymon** · 07-10-10 23:15

Originariamente inviato da mimmog

perchè spesso mi trovo chiamate a funzioni che non sono mensionate da nessuna parte....bho....

Ragazzi, stiamo parlando di JAVA. Il JAVA è un linguaggio cattivo e antipatico. Il JAVA non ti vuole. Programmare in JAVA è come scrivere su una tastiera mentre la signorina Rottenmaier ti guarda da sopra la spalla e ti da una bacchettata tutte le volte che pigi puntoevirgola

E parlo in senso generale.

Per quello che mi riguarda, in realtà, devo dire di trovarmi molto bene con l'architettura android. Il disegno dei layout ha finalmente senso, cosa che non mi è capitato di incontrare spessissimo usando le librerie per le GUI di JAVA e mi sembra che la divisione tra activity, service e tutto il resto sia molto razionale.

Certo, è un framework quindi ha tonnellate di XML che per un lungo periodo non puoi far altro che copincollare e delle classi che "misteriosamente" interagiscono fra loro. E' anche il suo vantaggio, perchè quel "mistero" non hai bisogno di svilupparlo, c'è già, basta capire come ragiona e sfruttarlo.

Per quello che riguarda metodi e robe che non si capisce bene da dove vengono beh... ringraziandosun JAVA viene sempre consegnato con un corposo JAVADOC

E come dico io il JAVADOC è il miglior amico del programmatore, dovresti passare più tempo sul JAVADOC che a scrivere in una somma totale.

Comunque perplessità, soprattutto agli inizi, sono sempre legittime, l'importante è non scoraggiarsi. Se volete provare a postare qui qualcuno di questi frammenti di codice oscuro troverai sicuramente qualcuno che vi darà delucidazioni

**TheCopacabanaMan** · 08-10-10 08:22

Mimmog? Scusa una domanda: dai tuoi post mi sembra di capire che tu sei abituato ad una programmazione strutturata o per tipi di dati astratti, ma non mi sembra che sei molto nell'ottica di una programmazione ad eventi.
Mi sbaglio oppure sto prendendo un granchio?

P.S. non voglio essere critico nei tuoi confronti, ma come ha detto gia' qualcuno prima di me, nelle prime fasi di apprendimento di un linguaggio, e' naturale copiare pezzi di codice, anche se non si capiscono. La programmazione "autonoma" viene col tempo & l'esperienza, quando si sono capiti i meccanismi del nuovo ambiente.

**mimmog** · 08-10-10 10:27

Bhe ragazzi che dire...prima di tutto sono contento di rilevare anche dalle parole dei più esperti che non sono il solo ad aver avuto problemi iniziali con questo linguaggio e che comunque copiare il codice è na cosa "normale" all'inizio. Prenderò sicuramente in considerazione il consiglio di Cymon sul javaDoc.

Originariamente inviato da TheCopacabanaMan

Mimmog? Scusa una domanda: dai tuoi post mi sembra di capire che tu sei abituato ad una programmazione strutturata o per tipi di dati astratti, ma non mi sembra che sei molto nell'ottica di una programmazione ad eventi.
Mi sbaglio oppure sto prendendo un granchio?

P.S. non voglio essere critico nei tuoi confronti, ma come ha detto gia' qualcuno prima di me, nelle prime fasi di apprendimento di un linguaggio, e' naturale copiare pezzi di codice, anche se non si capiscono. La programmazione "autonoma" viene col tempo & l'esperienza, quando si sono capiti i meccanismi del nuovo ambiente.

Per risponderti, come ho già detto in precedenza, programmo da oltre 10 anni con i più svariati linguaggi che però hanno sempre avuto una caratteristica comunue e cioè quella di essere strutturati alla stessa maniera con l'abitudine di scrivere le classi da me e oppure di utilizzare quelle già pronte che però nascevano e morivano lì invece java ha i costruttori, le sottoclassi, i metodi e questo mi ha spiazzato notevolmente...devo dire la verità.

Per spiegarmi meglio e dato che la discussione sembra interessare molti, inserisco qui di seguito uno dei tanti codici incriminati

Riprendo il discorso del codice del libro del Dr.Carli, precisamente quello che si trova nel Cap. 5 da pagina 178, che descrive la costruzione di un layout custom. Il codice è quello relativo alla classe FlowLayout.java

public class FlowLayout extends ViewGroup {<br />
	<br />
	private static final int DEFAULT_LAYOUT_WIDTH = 100;<br />
	private static final int DEFAULT_LAYOUT_HEIGHT = 100;<br />
	private int defaultWidth = DEFAULT_LAYOUT_WIDTH;<br />
	private int defaultHeight = DEFAULT_LAYOUT_HEIGHT;	<br />
	public class LayoutParams extends ViewGroup.LayoutParams {<br />
<br />
		/**<br />
		 * Se a true il corrispondente elemento viene possizionato nella riga<br />
		 * successiva<br />
		 */<br />
		public boolean isBreak = false;<br />
<br />
		/**<br />
		 * Larghezza massima della View<br />
		 */<br />
		public int maxWidth = 0;<br />
<br />
		/**<br />
		 * Altezza massima della View<br />
		 */<br />
		public int maxHeight = 0;<br />
		<br />
		public LayoutParams(Context context, AttributeSet attrs) {<br />
			super(context, attrs);<br />
			// Leggiamo i valori dei parametri definiti come attrs<br />
			// nel corrispondente file XML. Otteniamo il riferimento<br />
			// all'insieme dei valori attraverso il Context<br />
			TypedArray attrValues = context.obtainStyledAttributes(attrs,<br />
					R.styleable.FlowLayout);<br />
			// Il primo riguarda l'andata a capo o meno<br />
			isBreak = attrValues.getBoolean(R.styleable.FlowLayout_isBreak, false);<br />
			// Larghezza massima<br />
			maxWidth = attrValues.getInt(R.styleable.FlowLayout_maxWidth, -1);<br />
			// Altezza massima<br />
			maxHeight = attrValues.getInt(R.styleable.FlowLayout_maxHeight, -1);<br />
			// Facciamo in modo che le informazioni possano essere<br />
			Log.i("FlowLayout", "attrValues "+attrValues);<br />
			// riutilizzate<br />
			attrValues.recycle();<br />
		}<br />
		<br />
		public LayoutParams(LayoutParams layoutParams) {<br />
			super(layoutParams);<br />
			// Il primo riguarda l'andata a capo o meno<br />
			isBreak = layoutParams.isBreak;<br />
			// Larghezza massima<br />
			maxWidth = layoutParams.maxWidth;<br />
			// Altezza massima<br />
			maxHeight = layoutParams.maxHeight;			<br />
		}<br />
<br />
		public LayoutParams(int width, int height) {<br />
			super(width, height);<br />
			// Impostiamo i valori di default<br />
			isBreak = false;<br />
			// Larghezza massima<br />
			maxWidth = DEFAULT_LAYOUT_WIDTH;<br />
			// Altezza massima<br />
			maxHeight = DEFAULT_LAYOUT_HEIGHT;<br />
		}<br />
<br />
	<br />
<br />
	}<br />
<br />
	public FlowLayout(Context context) {<br />
		super(context);<br />
	}<br />
<br />
	public FlowLayout(Context context, AttributeSet attrs) {<br />
		super(context, attrs);<br />
		TypedArray attrValues = context.obtainStyledAttributes(attrs,<br />
				R.styleable.FlowLayout);<br />
		// Larghezza di default<br />
		defaultWidth = attrValues.getInt(R.styleable.FlowLayout_defaultWidth, DEFAULT_LAYOUT_WIDTH);<br />
		// Altezza di default<br />
		defaultHeight = attrValues.getInt(R.styleable.FlowLayout_defaultHeight, DEFAULT_LAYOUT_HEIGHT);<br />
		// Facciamo in modo che le informazioni possano essere<br />
		// riutilizzate<br />
		attrValues.recycle();		<br />
	}<br />
<br />
	@Override<br />
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {<br />
		// In base alle dimensioni a disposizione disponiamo i vari<br />
		// figli. <br />
		for (int i = 0; i < getChildCount(); i++) {<br />
			View child = getChildAt(i);<br />
			// Verifichiamo se questa View ha definito delle informazioni<br />
			// relativamente al layout<br />
			LayoutParams viewLayoutParams = (LayoutParams)child.getLayoutParams();<br />
			// Se è specificata una larghezza massia utilizziamo l'opzione AT_MOST mentre<br />
			// in caso contrario, utilizziamo la UNSPECIFIED<br />
			int childWidthSpec = 0;<br />
			if(viewLayoutParams.maxWidth<0){<br />
				// Caso di default<br />
				childWidthSpec = MeasureSpec.makeMeasureSpec(defaultWidth, MeasureSpec.UNSPECIFIED);<br />
			}else{<br />
				// Caso con vincolo<br />
				childWidthSpec = MeasureSpec.makeMeasureSpec(viewLayoutParams.maxWidth, MeasureSpec.AT_MOST);<br />
			}<br />
			// Stessa cosa per l'altezza<br />
			int childHeightSpec = 0;<br />
			if(viewLayoutParams.maxHeight<0){<br />
				// Caso di default<br />
				childHeightSpec = MeasureSpec.makeMeasureSpec(defaultHeight, MeasureSpec.UNSPECIFIED);<br />
			}else{<br />
				// Caso con vincolo<br />
				childHeightSpec = MeasureSpec.makeMeasureSpec(viewLayoutParams.maxHeight, MeasureSpec.AT_MOST);<br />
			}<br />
			child.measure(childWidthSpec, childHeightSpec);<br />
		}		<br />
		setMeasuredDimension(widthMeasureSpec, heightMeasureSpec);<br />
	}<br />
<br />
	@Override<br />
	protected void onLayout(boolean changed, int l, int t, int r, int b) {<br />
		// In base alle dimensioni delle View creiamo il FlowLayout<br />
		int currentX = 0;<br />
		int currentY = 0;<br />
		int maxHeight = 0;<br />
		int totalWidth = MeasureSpec.getSize(getMeasuredWidth());<br />
		for (int i = 0; i < getChildCount(); i++) {<br />
			// Riferimento al figlio i-esimo<br />
			View child = getChildAt(i);<br />
			// Otteniamo le informazioni di Layout<br />
			LayoutParams viewLayoutParams = (LayoutParams)child.getLayoutParams();<br />
			// Otteniamo le dimensioni<br />
			int measuredWidth =  child.getMeasuredWidth();<br />
			int measuredHeight =  child.getMeasuredHeight();<br />
			if(currentX+measuredWidth>totalWidth || viewLayoutParams.isBreak){<br />
				// In questo caso andiamo alla riga sottostante<br />
				currentX = 0;<br />
				currentY+=maxHeight;<br />
				maxHeight = 0;<br />
				child.layout(currentX, currentY, currentX+measuredWidth, currentY+measuredHeight);<br />
			}else{<br />
				// Altrimenti mettiamo il pulsante nella successiva<br />
				// posizione<br />
				child.layout(currentX, currentY, currentX+measuredWidth, currentY+measuredHeight);<br />
				maxHeight = (maxHeight<measuredHeight)?measuredHeight:maxHeight;<br />
			}<br />
			currentX+=measuredWidth;<br />
		}<br />
	}<br />
<br />
	@Override<br />
	protected LayoutParams generateDefaultLayoutParams() {<br />
		return new LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.FILL_PARENT);<br />
	}<br />
<br />
	@Override<br />
	public LayoutParams generateLayoutParams(AttributeSet attrs) {<br />
		return new LayoutParams(getContext(),attrs);<br />
	}<br />
<br />
	@Override<br />
	protected LayoutParams generateLayoutParams(android.view.ViewGroup.LayoutParams p) {<br />
		return new LayoutParams(p.height,p.width);<br />
	}<br />
<br />
	<br />
}<br />

Allora quello che dico quando parlo di ricordarsi il codice è :
1) possibile che per un layout personalizzato occorra ricordarsi 200 linee di codice ? lo trovo assurdo. Poi metodi e sottometodi per fare cosa ? dire che si sta utilizzando nell'XML l'attributo custom invece che android...

2) Prendiamo in cosiderazione i metodi obtainStyledAttributes o makeMeasureSpec o ancora gli ultimi 3 in Override, una persona che comincia mi dite come fa a ricordarli, sapere che esistono, che alcuni metodi sono in override, ricordare la sintassi, etc etc etc ?? non mi dite di guardare la documentazione perchè altrimenti una persona per scrivere un piccolo programma ci mette 2 anni....quello che mi sarei aspettato da Eclispe è che una volta scritto public class LayoutParams extends ViewGroup.LayoutParams lui mi mettesse già tutti i costruttori e mi desse indicazioni sui metodi da utilizzare per arrivare allo scopo altrimenti parliamoci chiaro, ci può anche essere un costruttore tipo

public LayoutParams(Context context, AttributeSet attrs) {   <br />
            super(context, attrs);   <br />
            // Leggiamo i valori dei parametri definiti come attrs   <br />
            // nel corrispondente file XML. Otteniamo il riferimento   <br />
            // all'insieme dei valori attraverso il Context   <br />
            TypedArray attrValues = context.obtainStyledAttributes(attrs,   <br />
                    R.styleable.FlowLayout);   <br />
            // Il primo riguarda l'andata a capo o meno   <br />
            isBreak = attrValues.getBoolean(R.styleable.FlowLayout_isBreak, false);   <br />
            // Larghezza massima   <br />
            maxWidth = attrValues.getInt(R.styleable.FlowLayout_maxWidth, -1);   <br />
            // Altezza massima   <br />
            maxHeight = attrValues.getInt(R.styleable.FlowLayout_maxHeight, -1);   <br />
            // Facciamo in modo che le informazioni possano essere   <br />
            Log.i("FlowLayout", "attrValues "+attrValues);   <br />
            // riutilizzate   <br />
            attrValues.recycle();   <br />
        }   <br />

ma se io non sò che alla fine devo utilizzare il metodo recycle(); sono fottuto...

onestamente mi sento umiliato a fare i copia ed incolla...

Spero di essermi spiegato...

**eafkuor** · 08-10-10 10:41

Ma guarda ti do ragione, dover definire un layout in questo modo è una cosa disumana..

**mimmog** · 08-10-10 11:17

Originariamente inviato da eafkuor

Ma guarda ti do ragione, dover definire un layout in questo modo è una cosa disumana..

E intanto, correggimi se sbaglio, ma non ci sono alternative...

**Cymon** · 08-10-10 11:23

Concordo con eafkuor che non si tratta di un codice semplice, anzi, direi già che è programmazione avanzata... molti programmatori android potrebbero non arrivare mai a dover fare una roba del genere. Ci sono un cifro di ottimi layout già fatti che funzionano in quasi ogni situazione

Vorrei però cercare di fare luce sul "ragionamento" che c'è dietro un codice del genere, che è un ragionamento al 90% JAVA e al 10% android.

1) Devo fare un'applicazione con un certo layout. Vado a spulciarmi tutti i layout già implementati nel SDK magari guardando questa pagina e scopro che nessuno mi piace!
2) Come si nota dal javadoc di uno qualsiasi dei layout già presenti (tho: il grezzissimo Linear) tutti i layout sono figli di ViewGroup.
3) A questo punto, visto che quello che mi serve non esiste, me lo faccio da me! E il punto di partenza deve essere ovviamente ViewGroup

public class FlowLayout extends ViewGroup

4) A questo punto mi sono già portato in casa un badile di metodi e un badile di variabili. Tutta roba tracciata nel JAVADOC di ViewGroup (te lo qui)
5) Da qui cominciano i dolori... Per far fare al layout quello che voglio io devo capire come ViewGroup ragiona e come "risponde" alle varie sollecitazioni con i suoi vari metodi. A questo punto individuo alcuni metodi che devono rispondere diversamente e li riscrivo secondo le mie esigenze. Ricordandomi anche di scrivere ex-novo il methodo onLayout che in ViewGroup è abstract e quindi è una scatola vuota che però in una classe "reale" deve essere riempita.
6) Finito questo lavoraccio è a questo punto che si esprime la smisurata potenza di JAVA. Perché il mio layout, ridefinito secondo il mio volere, può essere usato nel progetto come un qualsiasi dei Layout pre-esistenti e posso anche dimenticarmi del fatto di averlo fatto io e maneggiarlo in agilità.

Ah, un appunto, ricorsivamente :-P nel codice d'esempio il ragionamento viene ripetuto su ViewGroup.LayoutParams per le stesse ragioni.

Ripeto, comunque, che questo codice è TROPPO AVANZATO per uno sviluppatore android (e anche JAVA, in certi casi) alle prime armi. Android mette a disposizione una dozzina di ottimi layout e il suggerimento è cominciare usando quelli

Originariamente inviato da mimmog

E intanto, correggimi se sbaglio, ma non ci sono alternative...

Appunto, ce ne sono eccome! Basta usare i layout già esistenti!

**TheCopacabanaMan** · 08-10-10 11:30

Signori, ho idea che vi stiate arenando sui Layout, e in particolare su quel Custom Layout del libro.
Premetto che non ho il libro, e che ho litigato anch'io sui Layout standard

Ma perche' non passate avanti, e vedete qualche altro argomento?
Questo e' il mio parere personale, sia chiaro...

Mimmog? Gia' che hai il libro in mano, puoi dare un'occhiata al capitolo sul SQLite (se c'e') e vedere com'e' fatto? In particolare per quanto riguarda il trasferimento di un DB (con gia' dei dati dentro) su un dispositivo.
Grazie, ti devo una birra

**eafkuor** · 08-10-10 11:32

Originariamente inviato da Cymon

Appunto, ce ne sono eccome! Basta usare i layout già esistenti!

Esattamente. Tra RelativeLayout e LinearLayout si può fare praticamente tutto

Programmi di esempio ??

LinkBack

Strumenti discussione

Visualizza

Permessi di invio