Archivi tag: Programming

Leggere configurazione plist di default

Su mac è possibile leggere il file di default contenente la configurazione dell’applicativo in maniera molto semplice.
basta usare gli NSBundle

per poter accedere al bundle di default, il file info.plist generalmente contenuto delle Resources dell’applicativo:

1
NSBundle* mainBundle = [NSBundle mainBundle];

per poter accedere alle info contenute, basta usare il dictionary.

1
2
BOOL stats=[[[mainBundle infoDictionary] valueForKey:@"ShowStats"]boolValue];
NSString* version= [[mainBundle infoDictionary] valueForKey:@"Version"];

e’ possibile mettere nel bundle anche dictionary :

1
2
3
4
5
6
7
    NSDictionary* list = [[mainBundle infoDictionary ]valueForKey:@"Resolution"];
    if (list!=nil){
       
        NSNumber* width =[list valueForKey:@"Width"];
        NSNumber* height =[list valueForKey:@"Height"];
        return CGSizeMake([width doubleValue],[height doubleValue]);
    }

Creare Classi Statiche e Singleton in Objective C

Per creare una classe che sia raggiungibile da ogni parte del nostro codice, abbiamo due alternative: realizzare una classe statica con metodi e attributi statici, oppure implementare il pattern del Singleton.
Preferisco generalmente la seconda scelta più orientata ad un design pulito del nostro codice e rimanendo legato alla programmazione ad oggetti.

Per creare una classe statica, con attributi e metodi statici definiamo l’interfaccia:

1
2
3
4
@interface MyStaticClass : NSObject
+ (int)getIntMethod;
+ (void)setIntMethod:(int)value;
@end

e poi implementiamola:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#import "MyStaticClass.h"

@implementation MyStaticClass

static int staticValue = 1;

+ (int)getIntMethod {
  return staticValue;
}

+ (void)setIntMethod:(int)value {
  staticValue = value;
}

+ (id)alloc {
  [NSException raise:@"Non può essere istanziata format:@"Static class 'ClassName' non può essere instanziato"];
  return nil;
}

@end

importante l’override dell’alloc per non permettere alla classe di essere istanziata.

Per un approccio più elegante e sicuramente più riusabile, implementiamo invece il Design Pattern del Singleton:

1
2
3
4
5
6
7
8
9
@interface MySingleton : NSObject
{
}
-(int)getIntMethod;
-(void)setIntMethod:(int)value;

+ (MySingleton *) m_MySingleton;
 
@end

Implementiamo la nostra interfaccia:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#import "MySingleton.h"
 
@implementation MySingleton
 
static MySingleton *m_MySingleton =nil;
static int staticValue = 1;


+ (MySingleton *) m_MySingleton
{
  if (m_MySingleton == nil)
  {
    //creo l'istanza
    m_MySingleton = [[super allocWithZone:NULL] init];
  }
  return m_MySingleton;
}
 
- (int)getIntMethod {
  return staticValue;
}

- (void)setIntMethod:(int)value {
  staticValue = value;
}
+ (id)allocWithZone:(NSZone *)zone
{
 //sincronizzo in modo da rendere la fase di allocazione ThreadSafe
 //in modo da gestire più thread che richiedono contemporaneamente il Singleton
 @synchronized(self)
 {
   if (m_MySingleton == nil)
   {
     m_MySingleton = [super allocWithZone:zone];
     return m_MySingleton;
   }
 }
 return nil;
}
 
- (id)copyWithZone:(NSZone *)zone
{
 //non e' possibile clonarlo e quindi ritorna sempre la stessa istanza.
 return self;
}
 
- (id)retain
{
 return self;
}
 
- (NSUInteger)retainCount
{
 //in questo modo il suo refCount non scenderà mai a zero.
 return NSUIntegerMax;
}
 
- (void) release
{
  //non fa nulla.
}
 
- (id)autorelease
{
 return self;
}
 
@end

Piccola correzione. I metodi nel singleton ovviamente non devono essere statici (tranne il metodo che permette l’accesso all’istanza).

Estendere il WebClient per gestire un CookieStore

In C# , le system.net mettono a disposizione un oggetto chiamato WebClient per fare delle chiamate http in post a risorse identificate da un URI.

Nel mio caso l’ho utilizzato per fare delle chiamate dal CodeBehind di un applicazione web, per interrogare dei servizi web esposti in maniera restfull che accettavano dati in POST.

Dovendo gestire la sessione con questi servizi di backend e a volte avendo la necessità di dovergli pasare dei Cookie di autenticazione o altri cookie , mi sono trovato a doverlo estendere (per non lavorare direttamente con il WebRequest, oggetto su cui poggia il WebClient).

Il webclient offre pochissime funzionalità, ma estenderlo è molto facile.

In questo esempio aggiungiamo la possibilità di creare un proprio CookieStore, prima di una chiamata, in modo da potergli passare tutti i cookie (presi ad esempio dalla Request arrivata alla nostra pagina aspx) necessari al servizio che risponde all’URI interrogata.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
using System;

using System.Net;

using System.Web;

public class ExtendedWebClient : WebClient

{

    private CookieContainer m_container = new CookieContainer();

    protected override WebRequest GetWebRequest(Uri address)

    {

        WebRequest request = base.GetWebRequest(address);
        HttpWebRequest webRequest = request as HttpWebRequest;
        if (webRequest!=null){
            webRequest.CookieContainer = m_container;
        }
        return request;
    }

    public void SetCookies(HttpCookieCollection collection,string domain){
        m_container = new CookieStore();
        for (int j=0;j<collection.Count;j++){
            HttpCookie httpCookie = collection.Get(j);
            Cookie cookie = new Cookie();
            cookie.Domain = domain;
            cookie.Expires = httpCookie.Expires;  
            cookie.Name = httpCookie.Name;
            cookie.Path = httpCookie.Path;
            cookie.Secure = httpCookie.Secure;
            cookie.Value = httpCookie.Value;
            m_container.Add(cookie);
        }
    }
}

Oltre a gestire il cookieStore, dobbiamo preoccuparci della conversione dei cookies da HttpCookie (arrivati dalla Request) a quelli più dettagliati della System.Net.

Per utilizzare il nostro nuovo webclient e passargli i cookie possiamo fare in questo modo:

1
2
3
4
5
    ExtendendWebClient client = new ExtendedWebClient();
    client.SetCookies(request.Cookies,request.Url.Host);
    byte[] data = client.DownloadData("http://www.google.it");
    System.Text.Encoding enc = System.Text.Encoding.UTF8;
    string output = enc.GetString(data);

In questo modo tutti i cookie vengono impostati nel webclient prima di eseguire la webRequest.

Giocando con il parametro Domain, possiamo andare a filtrare i cookie che ci interessano per la chiamata in questione.