Programmi di esempio ??

[mimmog]

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]

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]

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]

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]

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.

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 exten<span class="forTooltip">ds</span> 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. <span class="forTooltip">Ot</span>teniamo 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 /> pr<span class="forTooltip">ot</span>ected 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'<span class="forTooltip">op</span>zione 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 />

 

1

public class FlowLayout extends ViewGroup {

2

3

    private static final int DEFAULT_LAYOUT_WIDTH = 100;

4

    private static final int DEFAULT_LAYOUT_HEIGHT = 100;

5

    private int defaultWidth = DEFAULT_LAYOUT_WIDTH;

6

    private int defaultHeight = DEFAULT_LAYOUT_HEIGHT;  

7

    public class LayoutParams extends ViewGroup.LayoutParams {

8

​

9

        /**

10

         * Se a true il corrispondente elemento viene possizionato nella riga

11

         * successiva

12

         */

13

        public boolean isBreak = false;

14

​

15

        /**

16

         * Larghezza massima della View

17

         */

18

        public int maxWidth = 0;

19

​

20

        /**

21

         * Altezza massima della View

22

         */

23

        public int maxHeight = 0;

24

25

        public LayoutParams(Context context, AttributeSet attrs) {

26

            super(context, attrs);

27

            // Leggiamo i valori dei parametri definiti come attrs

28

            // nel corrispondente file XML. Otteniamo il riferimento

29

            // all'insieme dei valori attraverso il Context

30

            TypedArray attrValues = context.obtainStyledAttributes(attrs,

31

                    R.styleable.FlowLayout);

32

            // Il primo riguarda l'andata a capo o meno

33

            isBreak = attrValues.getBoolean(R.styleable.FlowLayout_isBreak, false);

34

            // Larghezza massima

35

            maxWidth = attrValues.getInt(R.styleable.FlowLayout_maxWidth, -1);

36

            // Altezza massima

37

            maxHeight = attrValues.getInt(R.styleable.FlowLayout_maxHeight, -1);

38

            // Facciamo in modo che le informazioni possano essere

39

            Log.i("FlowLayout", "attrValues "+attrValues);

40

            // riutilizzate

41

            attrValues.recycle();

42

        }

43

44

        public LayoutParams(LayoutParams layoutParams) {

45

            super(layoutParams);

46

            // Il primo riguarda l'andata a capo o meno

47

            isBreak = layoutParams.isBreak;

48

            // Larghezza massima

49

            maxWidth = layoutParams.maxWidth;

50

            // Altezza massima

51

            maxHeight = layoutParams.maxHeight;         

52

        }

53

​

54

        public LayoutParams(int width, int height) {

55

            super(width, height);

56

            // Impostiamo i valori di default

57

            isBreak = false;

58

            // Larghezza massima

59

            maxWidth = DEFAULT_LAYOUT_WIDTH;

60

            // Altezza massima

61

            maxHeight = DEFAULT_LAYOUT_HEIGHT;

62

        }

63

​

64

65

​

66

    }

67

​

68

    public FlowLayout(Context context) {

69

        super(context);

70

    }

71

​

72

    public FlowLayout(Context context, AttributeSet attrs) {

73

        super(context, attrs);

74

        TypedArray attrValues = context.obtainStyledAttributes(attrs,

75

                R.styleable.FlowLayout);

76

        // Larghezza di default

77

        defaultWidth = attrValues.getInt(R.styleable.FlowLayout_defaultWidth, DEFAULT_LAYOUT_WIDTH);

78

        // Altezza di default

79

        defaultHeight = attrValues.getInt(R.styleable.FlowLayout_defaultHeight, DEFAULT_LAYOUT_HEIGHT);

80

        // Facciamo in modo che le informazioni possano essere

81

        // riutilizzate

82

        attrValues.recycle();       

83

    }

84

​

85

    @Override

86

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

87

        // In base alle dimensioni a disposizione disponiamo i vari

88

        // figli. 

89

        for (int i = 0; i < getChildCount(); i++) {

90

            View child = getChildAt(i);

91

            // Verifichiamo se questa View ha definito delle informazioni

92

            // relativamente al layout

93

            LayoutParams viewLayoutParams = (LayoutParams)child.getLayoutParams();

94

            // Se è specificata una larghezza massia utilizziamo l'opzione AT_MOST mentre

95

            // in caso contrario, utilizziamo la UNSPECIFIED

96

            int childWidthSpec = 0;

97

            if(viewLayoutParams.maxWidth<0){

98

                // Caso di default

99

                childWidthSpec = MeasureSpec.makeMeasureSpec(defaultWidth, MeasureSpec.UNSPECIFIED);

100

            }else{

101

                // Caso con vincolo

102

                childWidthSpec = MeasureSpec.makeMeasureSpec(viewLayoutParams.maxWidth, MeasureSpec.AT_MOST);

103

            }

104

            // Stessa cosa per l'altezza

105

            int childHeightSpec = 0;

106

            if(viewLayoutParams.maxHeight<0){

107

                // Caso di default

108

                childHeightSpec = MeasureSpec.makeMeasureSpec(defaultHeight, MeasureSpec.UNSPECIFIED);

109

            }else{

110

                // Caso con vincolo

111

                childHeightSpec = MeasureSpec.makeMeasureSpec(viewLayoutParams.maxHeight, MeasureSpec.AT_MOST);

112

            }

113

            child.measure(childWidthSpec, childHeightSpec);

114

        }       

115

        setMeasuredDimension(widthMeasureSpec, heightMeasureSpec);

116

    }

117

​

118

    @Override

119

    protected void onLayout(boolean changed, int l, int t, int r, int b) {

120

        // In base alle dimensioni delle View creiamo il FlowLayout

121

        int currentX = 0;

122

        int currentY = 0;

123

        int maxHeight = 0;

124

        int totalWidth = MeasureSpec.getSize(getMeasuredWidth());

125

        for (int i = 0; i < getChildCount(); i++) {

126

            // Riferimento al figlio i-esimo

127

            View child = getChildAt(i);

128

            // Otteniamo le informazioni di Layout

129

            LayoutParams viewLayoutParams = (LayoutParams)child.getLayoutParams();

130

            // Otteniamo le dimensioni

131

            int measuredWidth =  child.getMeasuredWidth();

132

            int measuredHeight =  child.getMeasuredHeight();

133

            if(currentX+measuredWidth>totalWidth || viewLayoutParams.isBreak){

134

                // In questo caso andiamo alla riga sottostante

135

                currentX = 0;

136

                currentY+=maxHeight;

137

                maxHeight = 0;

138

                child.layout(currentX, currentY, currentX+measuredWidth, currentY+measuredHeight);

139

            }else{

140

                // Altrimenti mettiamo il pulsante nella successiva

141

                // posizione

142

                child.layout(currentX, currentY, currentX+measuredWidth, currentY+measuredHeight);

143

                maxHeight = (maxHeight<measuredHeight)?measuredHeight:maxHeight;

144

            }

145

            currentX+=measuredWidth;

146

        }

147

    }

148

​

149

    @Override

150

    protected LayoutParams generateDefaultLayoutParams() {

151

        return new LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.FILL_PARENT);

152

    }

153

​

154

    @Override

155

    public LayoutParams generateLayoutParams(AttributeSet attrs) {

156

        return new LayoutParams(getContext(),attrs);

157

    }

158

​

159

    @Override

160

    protected LayoutParams generateLayoutParams(android.view.ViewGroup.LayoutParams p) {

161

        return new LayoutParams(p.height,p.width);

162

    }

163

​

164

165

}

166

​

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 />

19

 

1

public LayoutParams(Context context, AttributeSet attrs) {   

2

            super(context, attrs);   

3

            // Leggiamo i valori dei parametri definiti come attrs   

4

            // nel corrispondente file XML. Otteniamo il riferimento   

5

            // all'insieme dei valori attraverso il Context   

6

            TypedArray attrValues = context.obtainStyledAttributes(attrs,   

7

                    R.styleable.FlowLayout);   

8

            // Il primo riguarda l'andata a capo o meno   

9

            isBreak = attrValues.getBoolean(R.styleable.FlowLayout_isBreak, false);   

10

            // Larghezza massima   

11

            maxWidth = attrValues.getInt(R.styleable.FlowLayout_maxWidth, -1);   

12

            // Altezza massima   

13

            maxHeight = attrValues.getInt(R.styleable.FlowLayout_maxHeight, -1);   

14

            // Facciamo in modo che le informazioni possano essere   

15

            Log.i("FlowLayout", "attrValues "+attrValues);   

16

            // riutilizzate   

17

            attrValues.recycle();   

18

        }   

19

​

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]

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

[mimmog]

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]

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

1

 

1

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

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

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

[TheCopacabanaMan]

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]

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

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