Usare i Toast in Android

I Toast sono dei semplici avvisi mostrati all'utente.

Non hanno un'interazione diretta con l'utente, ma spariscono dopo un certo lasso di tempo.

Molto utili per brevi messaggi; io li uso inviare messaggi quando intercetto una eccezione.

Qui trovate la doc ufficiale; il metodo più interessante è makeText, che due versioni, di cui noi useremo quella che prevede l'impostazione del messaggio.

Vediamo qualche semplice esempio.

Toast t = Toast.makeText(getApplicationContext(), "Il file non esiste", Toast.LENGTH_SHORT);
t.show();

Il parametro è il Context; potrebbe andar bene anche un this.

Il secondo parametro il messaggio da visualizzare, e il terzo la durata (in questo caso uno degli standard di Android).

Sencha Touch List da MySQL

Seguendo la segnalazione di Ivan (leggi i commenti) ho cambiato i Model in modo da non usare metodi deprecati.

Un ringraziamento a Ivan per la segnalazione.

 

Facciamo un passo avanti con Sencha Touch.

Oggi vediamo il componente List.

Innanzitutto vi ricordo il link di riferimento: clicca qua.

Se cliccate su List vi verranno presentati già degli esempi di partenza.

Quello che faremo noi è caricare i dati prendendoli da MySQL.

La prima cosa da fare è preparare un file in un linguaggio lato server per interrogare il db.

Io lo faccio in PHP:

<?php

$host = "";
$user = "";
$pass = "";
$db = "";
$conn = mysqli_connect($host, $user, $pass, $db) or die(mysqli_connect_error());
if (mysqli_connect_errno()) {
    echo "Connessione fallita: " . die(mysqli_connect_error());
}
$result = mysqli_query($conn, "SELECT * FROM j25_content ORDER BY created DESC LIMIT 20");
$rows = array();
while ($row = mysqli_fetch_array($result, MYSQLI_ASSOC)) {
    $rows[] = array(
        'id' => $row['id'],
        'title' => $row['title'],
    );
}
echo json_encode($rows);
mysqli_close($conn);

L'output è in formato JSON e dalla tabella tiro fuori due campi.

Poi preperiamone un altro per estrarre un recordo singolo; dopo capirete il perchè:

<?php

$host = "";
$user = "";
$pass = "";
$db = "";
$conn = mysqli_connect($host, $user, $pass, $db) or die(mysqli_connect_error());
$cmd = "SELECT * FROM j25_content WHERE id = " . $_GET['id'];
if (mysqli_connect_errno()) {
    echo "Connessione fallita: " . die(mysqli_connect_error());
}
$result = mysqli_query($conn, $cmd);
$rows = array();
while ($row = mysqli_fetch_array($result, MYSQLI_ASSOC)) {
    $rows[] = array(
        'title' => $row['title'],
        'fulltext' => utf8_encode($row['fulltext'])
    );
}
echo json_encode($rows);
mysqli_close($conn);

La List la metteremo in una View in modo che quando cliccheremo su una riga andiamo a vederne il dettaglio.

GridView sorting in C#

Ed eccoci all'ultima parte dei tre articoli dedicati alla GV da code-behind (qui i primi due articoli: primo, secondo).

Qua vi parlo dell'implementazione del meccanismo di sorting.

Se si vuole usare il code-behind per la GV non basta attivare il sorting, ma bisogna scrivere il metodo a mano.

Prima di tutto dobbiamo fare alcune modifiche alla GV che adesso richiede due parametri:

protected void decoderViewSource(string sortExpr, string sortDir)
{

SqlConnection conn = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["MYDB"].ConnectionString);
String queryString = "SELECT * FROM siti";
try
{
conn.Open();
SqlDataAdapter adapter = new SqlDataAdapter(queryString, conn);
DataSet ds = new DataSet();
adapter.Fill(ds);
DataView dv = new DataView();
dv = ds.Tables[0].DefaultView;
if (sortExpr != string.Empty)
{
dv.Sort = string.Format("{0} {1}", sortExpr, sortDir);
}
DecoderView.DataSource = dv;
DecoderView.AutoGenerateColumns = false;
DecoderView.AutoGenerateSelectButton = true;
DecoderView.AllowSorting = true;
DecoderView.AllowPaging = true;
DecoderView.CssClass = "grid";
DecoderView.PageSize = int.Parse(ddlPagine.SelectedValue);
DecoderView.PagerSettings.Visible = false;
DecoderView.DataBind();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conn.Close();
}
}

L'unica differenza sta nei due parametri string.

MySQL Stored Procedure

Dopo aver parlato delle viste affronto il "problema" delle Stored Procedure (SP) in MySQL.

Le SP portanto diversi vantaggi, tra i quali la velocità di esecuzione spicca sugli altri.

Le SP sono più veloci in quanto rimangono nella cache del server e quindi sono più veloci se devono essere richiamate spesso.

Inoltre tutta la logica di esecuzione è lasciata al db separando così i dati dal codice (PHP, Java, C#, ecc....vale per tutti).

I maggiori punti a sfavore derivano dal fatto che non è sempre facile scrivere un layer di astrazione nei vari linguaggi e che non è possibile effetturane il debug.

Per quanto riguarda il primo punto, ciò deriva dal fatto che MySQL non ha una stretta interazione come succede con SQL Server e Asp.NET.

Comunque vediamo come gestire le SP.

Prima di tutto la creazione; connettiamoci al db e scriviamo:

mysql> DELIMITER //
mysql> CREATE PROCEDURE getBook()
-> BEGIN
-> SELECT * FROM book;
-> END//
Query OK, 0 rows affected (0.02 sec)

mysql> DELIMITER ;

DELIMITER // serve per cambiare il delimitatore di fine comando; in questo caso ho impostato // ma può essere uno qualsiasi.

Alla fine ho reimpostato quello tradizionale (il ;).

Si tratta di una vera e propria istruzione; sembra una funziona in VB......

Le istruzioni che ci interessano vanno dentro il blocco BEGIN-END.

getBook() è il nome che gli ho assegnato io; le parenetsi sono obbligatorie proprio come in una funzione/metodo in un linguaggio, e questo perchè è possibile passrgli dei parametri (li vedremo dopo).

Le viste in MySQL

In questi giorni ho avuto a che fare con le viste in MySQL.

Detta in parole povere una view è una tabella virtuale formata dal risultato di una SELECT.

Una volta salvata una view è simile a una classica tabella, formata da righe e colonne ed è interrogata come una normale tabella.

L'utilizzo dell views porta con se diversi vantaggi:

• semplifica query complesse
• limita l'accesso ad alcuni dati che si vogliono tenere nascosti
• extra security derivata dal fatto che la view è una tabella a sola lettura; gli utenti possono solo visualizzare i dati
• ecc

Creare una view non è difficile.

La sintassi genereale è questa:

CREATE
[ALGORITHM = {MERGE | TEMPTABLE | UNDEFINED}]

VIEW [database_name]. [view_name]

AS
[SELECT statement]

Con MERGE la SELECT viene "mescolata" con l'istruzione che richiama la vista stessa.

Con TEMPTABLE la SELECT relativa alla vista viene utilizzata per creare una tabella temporanea, sulla quale viene poi eseguita l'istruzione richiesta.

Con UNDEFINED sceglierà MySQL cosa usare, ed in genere preferisce MERGE.

UNDEFINED è l'impostazione di default.

Come nome potete impostare sia il nome col prefisso del nome del db, che senza.

Infine abbiamo l'istruzione SELECT che segue alcune regole:

• non possono essere incluse subquery
• non possono essere usate variabili
• non possono essere usati prepared statement
• non possono essere usate altre view o tabella temporenee
• non possono essere associate a triggers

Vi mostro la mia view:

CREATE VIEW bookv

AS 

SELECT name, author_name, editor_name, price, isbn, note

FROM book

INNER JOIN author ON book.author_id=author.author_id

INNER JOIN editor ON book.editor_id=editor.editor_id;

Come potete vedere nulla di complicato e se andate a controllare le tabelle del vostro db comparirà anche la view:

mysql> show tables;
+-------------------+
| Tables_in_library |
+-------------------+
| author            |
| book              |
| bookv             |
| editor            |
+-------------------+

A questo punto vi basterà interrogare la view per recuperare quei dati:

SELECT * FROM bookv;

VISTE AGGIORNABILI