Creazione di post automatici su Facebook con RFID su Android (7)

Qui viene descritto come pubblicare su Facebook in modo automatico mediante un telefono abilitato con Rfid. In pratica si tratta dell'unione di diversi post precedenti ed in particolare questo e questo


A differenza di Java, per creare una connessione Http in Android si devono prima settare i permessi nel file Manifest.xml (come al solito le modifiche rispetto ai post precedenti sono in giallo)


Manifest.xml
---------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.test4"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="7"
        android:targetSdkVersion="16" />

    <uses-permission android:name="android.permission.NFC"/>
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission  android:name="android.permission.ACCESS_NETWORK_STATE" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.test4.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>


        <activity android:label="@string/event_verify" android:name="verifytagscanact">
            <intent-filter>
                <action android:name="android.nfc.action.TECH_DISCOVERED"/>
            </intent-filter>
            <meta-data android:name="android.nfc.action.TECH_DISCOVERED" android:resource="@xml/filter_nfc"/>
        </activity>

    </application>

</manifest>

---------------------------------------------------

Nella main le modifiche sono minime e piuttosto simili a Java per l'oggetto HttpConnection. Molto peculiari sono le prime righe dopo OnCreate perche' sono relative ad una gestione specifica di Android (come si puo' leggere meglio spiegato in questo post)

MainActivity.java

---------------------------------------------------

package com.example.test4;

import android.os.Bundle;

import android.app.Activity;

import android.os.StrictMode;

import android.util.Log;

import android.view.Menu;

import android.nfc.Tag;

import android.nfc.NfcAdapter;

import android.nfc.tech.MifareClassic;

import android.app.PendingIntent;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.IntentFilter.MalformedMimeTypeException;

import android.widget.Toast;

import java.math.BigInteger;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.HttpURLConnection;

import java.net.MalformedURLException;

import java.net.URL;

public class MainActivity extends Activity {

    NfcAdapter adapter;

    PendingIntent pendingIntent;

    IntentFilter writeTagFilters[];

    String[][] techListsArray;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        StrictMode.ThreadPolicy policy = new StrictMode.

        ThreadPolicy.Builder().permitAll().build();

        StrictMode.setThreadPolicy(policy);

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        adapter = NfcAdapter.getDefaultAdapter(this);

        pendingIntent = PendingIntent.getActivity(this, 0, new Intent(this, getClass()).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), 0);

        IntentFilter tagDetected = new IntentFilter(NfcAdapter.ACTION_TECH_DISCOVERED);

        try {

            tagDetected.addDataType("*/*");

        }

        catch (MalformedMimeTypeException e) {

            throw new RuntimeException("fail", e);

        }

        tagDetected.addCategory(Intent.CATEGORY_DEFAULT);

        writeTagFilters = new IntentFilter[] { tagDetected };

        techListsArray = new String[][] { new String[] { MifareClassic.class.getName() } };

    }

    static String bin2hex(byte[] data) {

        return String.format("%0" + (data.length * 2) + "X", new BigInteger(1,data));

    }

    @Override

    protected void onNewIntent(Intent intent){

        //Toast.makeText(getApplicationContext(), "Trovato Tag", Toast.LENGTH_SHORT).show();

        Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);

        byte[] tagId = intent.getByteArrayExtra(NfcAdapter.EXTRA_ID);

        // trasmissione dati al server

      try {
            URL url = new URL("http://m.msn.unifi.it/luca/examples/rfid_server3.php?rfid="+bin2hex(tag.getId())+"&msg=cellulare");
            HttpURLConnection connection;
            connection = (HttpURLConnection) url.openConnection();

            readStream(connection.getInputStream());
            Toast.makeText(getApplicationContext(), bin2hex(tag.getId()), Toast.LENGTH_SHORT).show();
            } catch (Exception e) {
            e.printStackTrace();
              }

    

    }


 private void readStream(InputStream in) {
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new InputStreamReader(in));
                String line = "";
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

        }

    public void onPause() {

        super.onPause();

        adapter.disableForegroundDispatch(this);

    }

    public void onResume() {

        super.onResume();

        adapter.enableForegroundDispatch(this, pendingIntent, writeTagFilters, techListsArray);

    }

    @Override

    public boolean onCreateOptionsMenu(Menu menu) {

        // Inflate the menu; this adds items to the action bar if it is present.

        getMenuInflater().inflate(R.menu.main, menu);

        return true;

    }

    

}

---------------------------------------------------
deve essere infine modificato il file /res/values/strings.xml


il file sul server e' identico a quello usato in precedenza

Accoppiamento WiFly con lettore Rfid

Per lo shield WiFly e' stata effettuata la patch descritta qui


Per la connessione del lettore Rfid si usano i seguenti pin

VCC : 3.3V
GND :

MOSI: Pin 11 / ICSP-4
MISO: Pin 12 / ICSP-1
SCK: Pin 13 / ISCP-3
SS: Pin 10
RST: Pin 9

da notare che vista la presenza dello shield il PIN 3.3V risulta coperto per cui e' stato necessario mettere una patch piegando il piedino in modo da poter appoggiare lo shield. In realta' si potrebbe rubare la corrente saldando un contatto direttamente sullo shield

Lo sketch inizializza il lettore Rfid e la WiFly. Successivamente nel loop attende che venga passato il tag Rfid, lo legge ed invia il codice allo script in Php sul server

---------------------------------------------------
#include <WiFlyHQ.h>
#include <SPI.h>
#include <RFID.h>
#include <SoftwareSerial.h>


//WiFi
SoftwareSerial wifiSerial(2,3);
WiFly wifly;
const char mySSID[] = "TIM_PN51T_C0D1";
const char myPassword[] = "50276337";
const char site[] = "m.msn.unifi.it";

//RFid
#define SS_PIN 10
#define RST_PIN 9
RFID rfid(SS_PIN, RST_PIN); 
int serNum0;
int serNum1;
int serNum2;
int serNum3;
int serNum4;

void terminal();

void setup()
{
    char buf[32];
    
    SPI.begin(); 
    rfid.init();

    Serial.begin(9600);
    pinMode(pushButton, INPUT);

    Serial.println("Starting");
    Serial.print("Free memory: ");
    Serial.println(wifly.getFreeMemory(),DEC);

    wifiSerial.begin(9600);
    if (!wifly.begin(&wifiSerial, &Serial)) {
        Serial.println("Failed to start wifly");
terminal();
    }

    /* Join wifi network if not already associated */
    if (!wifly.isAssociated()) {
/* Setup the WiFly to connect to a wifi network */
Serial.println("Joining network");
wifly.setSSID(mySSID);
wifly.setPassphrase(myPassword);
wifly.enableDHCP();

if (wifly.join()) {
   Serial.println("Joined wifi network");
} else {
   Serial.println("Failed to join wifi network");
   terminal();
}
    } else {
        Serial.println("Already joined network");
    }

    //terminal();

    Serial.print("MAC: ");
    Serial.println(wifly.getMAC(buf, sizeof(buf)));
    Serial.print("IP: ");
    Serial.println(wifly.getIP(buf, sizeof(buf)));
    Serial.print("Netmask: ");
    Serial.println(wifly.getNetmask(buf, sizeof(buf)));
    Serial.print("Gateway: ");
    Serial.println(wifly.getGateway(buf, sizeof(buf)));

    wifly.setDeviceID("Wifly-WebClient");
    Serial.print("DeviceID: ");
    Serial.println(wifly.getDeviceID(buf, sizeof(buf)));


}

void loop()
{
    if (wifly.available() > 0) {
char ch = wifly.read();
Serial.write(ch);
if (ch == '\n') {
   /* add a carriage return */ 
   Serial.write('\r');
}
    }

    if (Serial.available() > 0) {
wifly.write(Serial.read());
    }


 if (rfid.isCard()) {
        if (rfid.readCardSerial()) {
              if (wifly.isConnected()) {
                  Serial.println("Old connection active. Closing");
                  wifly.close();
                  }

              if (wifly.open(site, 80)) {
                  Serial.print("Connected to ");
                  Serial.println(site);
                  } else {
                  Serial.println("Failed to connect");
                }
                serNum0 = rfid.serNum[0];
                serNum1 = rfid.serNum[1];
                serNum2 = rfid.serNum[2];
                serNum3 = rfid.serNum[3];
                serNum4 = rfid.serNum[4];
                String Id = String(rfid.serNum[0],HEX)+String(rfid.serNum[1],HEX)+String(rfid.serNum[2],HEX)+String(rfid.serNum[3],HEX)+ String(rfid.serNum[4],HEX);
                Serial.println(Id);
                String params = "{}";
                String paramsLength = String(params.length());
                /* Send the request */
                
                wifly.println("POST /luca/examples/rfid_server2.php?rfid="+Id+"&msg=definitivo HTTP/1.1"); // paste your number here
                wifly.println("Host: m.msn.unifi.it:80");
                wifly.print("Content-Length: ");
                wifly.println(paramsLength);
                wifly.println("User-Agent: lifegraph/0.0.1");
                wifly.println();
                wifly.println(params);
             } 
        
    rfid.halt();
    }
}

/* Connect the WiFly serial to the serial monitor. */
void terminal()
{
    while (1) {
if (wifly.available() > 0) {
   Serial.write(wifly.read());
}


if (Serial.available() > 0) {
   wifly.write(Serial.read());
}
    }
}

-----------------------------------------------------------




Script Php

-----------------------------------------------------------
require_once '../src/facebook.php';
//Luca
if ($_GET["rfid"] == "f479abb492")
    {
    $accessToken = "CAAJkNq2LttoBAJywtmNSbVHqFPubOjYmQ2yyUG4kpibD75BHid9J7xsvif8osSOc4ewgK4aYerrLZBsZCQM5wykRTYVLDkCJXlXYl3gi8WFRQ8U4p4y4ZAXYsdamz6RVdRJZAe4vZA80mWBayuG0qc4IAj2TMDmQXKiv1OrKp8CwKjD6xxxxxxxxxxxxxxxxx";
    print "Luca<br>";
    }
//Gabriele
if ($_GET["rfid"] == "0800364CD7")
    {
    $accessToken = "CAAJkNq2LttoBACxBnb2QjtvbedXaRNwWDAniJsIE59ZBZBjDgsT1FtTmBIVxZAmS4MbbEXY8Y9kduFxfBmQhEgflGxdvXjRG1CAMHICGlHGaCXfP81VlLRySw2m8lzatt074jHsDKYlQjwZAHI725LLSMsAjjDDty3GDOrso0361xLCDzxxxxxxxxxxxxxxxxxxxxxxxxxx";
    print "Gabriele";
    }

$appid = '6731359560xxxxxx';
$appsecret = 'dde6cfb07dbb769c7efe94xxxxxxxxx';
$msg = $_GET["msg"];
$title = 'Dove sono ??';
$uri = 'http://debiaonoldcomputers.blogspot.com/';
$desc = 'Sono ad Arcetri';
$pic = 'http://www.dst.unifi.it/themes/Boozook/images/testa.gif';
$action_name = 'Link';
$action_link = 'http://www.geo.unifi.it/';

$facebook = new Facebook(array(
 'appId' => $appid,
 'secret' => $appsecret,
 'cookie' => false,
 ));

 $user = $facebook->getUser();


$attachment = array(
'access_token' => $accessToken,
'message' => $msg,
'name' => $title,
'link' => $uri,
'description' => $desc,
'picture'=>$pic,
'actions' => json_encode(array('name' => $action_name,'link' => $action_link))
);
$status = $facebook->api("/me/feed", "post", $attachment);
print "Ok";
?> 

Trasmissione radio digitale a 433 MHz con Arduino

Con pochi euro si possono trovare coppie di trasmettitore e ricevitore radio a 433 MHz per far dialogare due schede Arduino nell'arco di qualche decina di metri
Attenzione : vengono venduti componenti, molto simili nell'aspetto, che lavorano a 315 MHz. Il codice e' identico per le due versioni di frequenza, l'importante e' non mischiare un trasmettitore a 433 MHz ed un ricevitore a 315 MHz

La libreria di riferimento per questo tipo di componenti e' VirtualWire

Le connessioni sono molto semplice perche' sono sufficienti tre fili
Vcc (da 5 a 12 V)
GND
Dati

(il ricevitore ha 4 pin ma i due pin centrali normalmente portano entrambi il segnale dati)
Al momento dell'acquisto conviene comprare componenti provvisti di antenna (nella foto si vede che l'antenna del trasmettitore e' stata aggiunta in un secondo momento mentre il ricevitore ha una antenna spiralata)
Di default il pin di trasmissione e' settato sul D12 mentre il pin di ricezione di default e' sul pin D11 (questi possono essere modificato tramite vw_set_tx_pin(nr_pin) e vw_set_rx_pin(nr_pin);

Nella foto un esempio di trasmissione tra due Arduino Nano

In rosso trasmettitore, in verde ricevitore

Attenzione: i componenti vengono venduti senza antenna. E' necessario aggiungere una antenna di 17 cm per i sensori a 433 MHz e 21 cm per i sensori a 315 MHz

Prove effettuate in campo hanno mostrato che il segnale si segue in spazio aperto fino a oltre 150 m con alimentazione a 5 V e baud rate di 200 bit/s

Trasmettitore
--------------------------------------------------------------
#include <VirtualWire.h>

void setup()
{
    Serial.begin(9600);  // Debugging only
    Serial.println("setup");

    // Initialise the IO and ISR
    vw_set_ptt_inverted(true); // Required for DR3100
    vw_setup(2000); // Bits per sec
}

void loop()
{
    const char *msg = "hello";

    digitalWrite(13, true); // Flash a light to show transmitting
    vw_send((uint8_t *)msg, strlen(msg));
    vw_wait_tx(); // Wait until the whole message is gone
    digitalWrite(13, false);
    delay(200);
}
--------------------------------------------------------------

Ricevitore
--------------------------------------------------------------
#include <VirtualWire.h>

void setup()
{
    Serial.begin(9600); // Debugging only
    Serial.println("setup");

    // Initialise the IO and ISR
    vw_set_ptt_inverted(true); // Required for DR3100
    vw_setup(2000); // Bits per sec

    vw_rx_start();       // Start the receiver PLL running
}

void loop()
{
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;

    if (vw_get_message(buf, &buflen)) // Non-blocking
    {
int i;

        digitalWrite(13, true); // Flash a light to show received good message
// Message with a good checksum received, dump it.
Serial.print("Got: ");

for (i = 0; i < buflen; i++)
{
   Serial.print(buf[i], HEX);
   Serial.print(" ");
}
Serial.println("");
        digitalWrite(13, false);
    }
}
--------------------------------------------------------------

Http Client in Java/Android

Un breve esempio di come realizzare una connessione automatica in protocollo HTTP mediante Java/Android


-------------------------------------------------------------------------------------
package httpclient;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.Proxy;
import java.net.URL;


public class Httpclient {

    public static void main(String[] args) throws IOException {
    try {
        URL url = new URL("http://www.google.it/");
               
        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.arpat.toscana.it", 8080));
        HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);
        //se non c'e' proxy commentare la riga superiore e decommentare quella inferiore
        //HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        
        //decommentare le due righe successive per mostrare il codice di errore HTTP
        //ritornato dal server
        //int code = connection.getResponseCode();
        //System.out.println(Integer.toString(code));
        
        BufferedReader read = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String line;
        line = read.readLine();
        String html = "";
        while(line!=null) {
            html += line;
            line = read.readLine();
        }
        System.out.println(html);
} catch(MalformedURLException ex) {
} catch(IOException ioex) {
}
    }
    
}

XBee Shield e WiFly su Arduino Uno

Per dotare di connessione WiFi una scheda Arduino, in attesa dell'uscita di Arduino Yum,  ho preso su una schedina WiFly RN-VX

La scheda WiFly necessita di sole 4 connessioni : Vcc 3.3 V(Pin 1) , GND (Pin 10), Rx (Pin 3) ,Tx (pin 2)

Attenzione: la scheda non tollera le tensioni superiori a 3.3. V per cui il collegamento diretto dei Pin 2 e 3 ai pin digitali di una Arduino Uno brucia la scheda (esperienza diretta) per cui deve essere presente un regolatore di tensione. Sullo shield sono presenti delle resistenze di protezione

La WiFly e' stata connessa su uno shield XBee. Studiando lo shield si vede chiaramente che i Pin 2 e 3 della WiFly vengono connessi con i Pin D0 e D1 dell'Arduino. Cio' crea problemi perche' questi pin sono deputati alla trasmissione della seriale via USB. Per questo motivo i piedini del Pin D0 e D1 sono stati piegati verso l'esterno e tramite una patch sono stati connessi ai pin D2 e D3 dell'Arduino

D0 => D3
D1 => D2

Si notino i cavi arancioni che escono lateralmente dai Pin D0 e D1

Da notare che sulla scheda vi sono anche due Jumper in Blu. La posizione corretta e' quella sulla scritta USB

A questo punto per far funzionare la modalita' WiFi dell'Arduino e' sufficiente scaricare la libreria WiFlyHQ  e caricare l'esempio httpclient modificando la riga come segue la riga sulla SoftwareSerial oltre alle proprie impostazioni della rete WiFi

SoftwareSerial wifiSerial(2,3);

----------------------------------------------

#include <WiFlyHQ.h>

#include <SoftwareSerial.h>
SoftwareSerial wifiSerial(2,3);

//#include <AltSoftSerial.h>
//AltSoftSerial wifiSerial(8,9);

WiFly wifly;

/* Change these to match your WiFi network */
const char mySSID[] = "TIM_PN51T_C0D1"; // Wifi network name
const char myPassword[] = "50276337"; // Wifi network password

//const char site[] = "arduino.cc";
//const char site[] = "www.google.co.nz";
const char site[] = "hunt.net.nz";

void terminal();

void setup()
{
    char buf[32];

    Serial.begin(115200);
    Serial.println("Starting");
    Serial.print("Free memory: ");
    Serial.println(wifly.getFreeMemory(),DEC);

    wifiSerial.begin(9600);
    if (!wifly.begin(&wifiSerial, &Serial)) {
        Serial.println("Failed to start wifly");
terminal();
    }

    /* Join wifi network if not already associated */
    if (!wifly.isAssociated()) {
/* Setup the WiFly to connect to a wifi network */
Serial.println("Joining network");
wifly.setSSID(mySSID);
wifly.setPassphrase(myPassword);
wifly.enableDHCP();

if (wifly.join()) {
   Serial.println("Joined wifi network");
} else {
   Serial.println("Failed to join wifi network");
   terminal();
}
    } else {
        Serial.println("Already joined network");
    }

    //terminal();

    Serial.print("MAC: ");
    Serial.println(wifly.getMAC(buf, sizeof(buf)));
    Serial.print("IP: ");
    Serial.println(wifly.getIP(buf, sizeof(buf)));
    Serial.print("Netmask: ");
    Serial.println(wifly.getNetmask(buf, sizeof(buf)));
    Serial.print("Gateway: ");
    Serial.println(wifly.getGateway(buf, sizeof(buf)));

    wifly.setDeviceID("Wifly-WebClient");
    Serial.print("DeviceID: ");
    Serial.println(wifly.getDeviceID(buf, sizeof(buf)));

    if (wifly.isConnected()) {
        Serial.println("Old connection active. Closing");
wifly.close();
    }

    if (wifly.open(site, 80)) {
        Serial.print("Connected to ");
Serial.println(site);

/* Send the request */
wifly.println("GET / HTTP/1.0");
wifly.println();
    } else {
        Serial.println("Failed to connect");
    }
}

void loop()
{
    if (wifly.available() > 0) {
char ch = wifly.read();
Serial.write(ch);
if (ch == '\n') {
   /* add a carriage return */ 
   Serial.write('\r');
}
    }

    if (Serial.available() > 0) {
wifly.write(Serial.read());
    }
}

/* Connect the WiFly serial to the serial monitor. */
void terminal()
{
    while (1) {
if (wifly.available() > 0) {
   Serial.write(wifly.read());
}


if (Serial.available() > 0) {
   wifly.write(Serial.read());
}
    }

}

Conteggio Like mediante Arduino

In questo post viene descritto come effettuare il conteggio dei Like di una pagina Facebook mediante Arduino

Sono sono stati utilizzati
Arduino UNO
Shield Ethernet
Bridge Ethernet-WiFi Vonets
Display LCD 1602 (modalita' I2C)

Il montaggio e' piuttosto semplice.
Il bridge e' stato usato per dare capacita' wireless all'Arduino senza utilizzare il costoso shield apposito
Il montaggio dei cavi del display e' spiegato in questo post

Di fatto l'Arduino efffettua una richiesta ad uno script Php che e' su server remoto, legge e mette a display il risultato (il tutto e' basato sull'Esempio WebClient della libreria Ethernet di Arduino)
-------------------------------------
#include <SPI.h>
#include <Ethernet.h>
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>


LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display


String currentLine = "";            
String fbcount = "";                


byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
char server[] = "m.xxxx.unifi.it";    

IPAddress ip(192,168,0,177);
EthernetClient client;

void setup() {
   lcd.init();    
   lcd.backlight();
   lcd.print("Facebook");
   lcd.setCursor(0,1);
   lcd.print("Like counter");
   
  Serial.begin(9600);
   while (!Serial) {
  }

  // start the Ethernet connection:
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    Ethernet.begin(mac, ip);
  }
  delay(1000);
  Serial.println("connecting...");

  // if you get a connection, report back via serial:
  if (client.connect(server, 80)) {
    Serial.println("connected");
    client.println("GET /xxxxxxx/like3.php HTTP/1.1");
    client.println("Connection: close");
    client.println();
  } 
  else {
    Serial.println("connection failed");
  }
}

void loop()
{
  if (client.available()) {
    char c = client.read();
    //Serial.print(c);

    currentLine += c; 


      if ( currentLine.startsWith("Like:")) {
         
        fbcount += c;
        Serial.println(fbcount);
        lcd.clear();
        lcd.print("Like"+fbcount);

      }

     if (c == '\n') {
        currentLine = "";
        fbcount = "";
      } 

    
  }

  if (!client.connected()) {
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();

    while(true);
  }
}

--------------------------------------------------
Script PHP
--------------------------------------------------
<?
require_once '../src/facebook.php';

$appid = '673135956047578';
$appsecret = 'dde6cfb07dbb769c7efe949c20afd73d';

$facebook = new Facebook(array(
 'appId' => $appid,
 'secret' => $appsecret,
 'cookie' => false,
 ));

$like = array(
    'method' => 'fql.query',
    'query' => 'select fan_count from page where page_id=266068113416863;'
);

$result = $facebook->api($like);

print "Like:".$result[0]['fan_count'];
?>

Lettura di RFID Mifare con API di Android

In questo post viene descritto come leggere i tag Rfid Mifare Classic (13.56 MHz) disponendo di un telefono con antenna NFC come il Nexus S (attenzione che per leggere

L'interno con l'hardware NFC di un Nexus S (IFixIt)

Si parte da un progetto vuoto (Hello World) e si effettuano le modeste modifiche indicate in giallo nel listato seguente


Per prima cosa si deve modificare il file Manifest per dichiarare l'uso del sensore NFC e si deve dichiare una nuova intent che si apre quando viene passato un tag sotto il lettore

Manifest.xml
------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.test4"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="10"
        android:targetSdkVersion="16" />

    <uses-permission android:name="android.permission.NFC"/>

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.test4.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>


        <activity android:label="@string/event_verify" android:name="verifytagscanact">
            <intent-filter>
                <action android:name="android.nfc.action.TECH_DISCOVERED"/>
            </intent-filter>
            <meta-data android:name="android.nfc.action.TECH_DISCOVERED" android:resource="@xml/filter_nfc"/>
        </activity>

    </application>

</manifest>

------------------------------------------------

Si deve creare poi una nuova cartella xml nelle risorse e si crea un nuovo file filter_nfc

/xml/filter_nfc.xml

------------------------------------------------

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <tech-list>
        <tech>android.nfc.tech.NfcA</tech>
        <tech>android.nfc.tech.MifareClassic</tech>
    </tech-list>
</resources>

------------------------------------------------

la Main Activity e' composta da un solo Adapter che apre una nuova intent. A questo punto si apre la funzione OnNewIntent che legge il contenuto del tag

MainActivity.java

------------------------------------------------
package com.example.test4;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.nfc.Tag;
import android.nfc.NfcAdapter;
import android.nfc.tech.MifareClassic;
import android.app.PendingIntent;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.IntentFilter.MalformedMimeTypeException;
import android.util.Log;
import android.widget.Toast;
import java.math.BigInteger;

public class MainActivity extends Activity {

    NfcAdapter adapter;
    PendingIntent pendingIntent;
    IntentFilter writeTagFilters[];
    String[][] techListsArray;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        adapter = NfcAdapter.getDefaultAdapter(this);

        pendingIntent = PendingIntent.getActivity(this, 0, new Intent(this, getClass()).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), 0);
        IntentFilter tagDetected = new IntentFilter(NfcAdapter.ACTION_TECH_DISCOVERED);
        try {
            tagDetected.addDataType("*/*");
        }
        catch (MalformedMimeTypeException e) {
            throw new RuntimeException("fail", e);
        }
        tagDetected.addCategory(Intent.CATEGORY_DEFAULT);
        writeTagFilters = new IntentFilter[] { tagDetected };

        techListsArray = new String[][] { new String[] { MifareClassic.class.getName() } };

    }

    static String bin2hex(byte[] data) {
        return String.format("%0" + (data.length * 2) + "X", new BigInteger(1,data));
    }

    @Override
    protected void onNewIntent(Intent intent){
        Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
        byte[] tagId = intent.getByteArrayExtra(NfcAdapter.EXTRA_ID);
        Toast.makeText(getApplicationContext(), bin2hex(tag.getId()), Toast.LENGTH_SHORT).show();


    }

    public void onPause() {
        super.onPause();
        adapter.disableForegroundDispatch(this);
    }

    public void onResume() {
        super.onResume();
        adapter.enableForegroundDispatch(this, pendingIntent, writeTagFilters, techListsArray);
    }


    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }
    
}

------------------------------------------------