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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
/**
*
*/
package se.leap.leapclient;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Locale;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import android.content.Context;
import android.app.Activity;
import android.content.SharedPreferences;
/**
* @author Sean Leonard <meanderingcode@aetherislands.net>
*
*/
public final class Provider implements Serializable {
private static final long serialVersionUID = 6003835972151761353L;
private static Provider instance = null;
// We'll access our preferences here
private static SharedPreferences preferences = null;
// Represents our Provider's provider.json
private static JSONObject definition = null;
// Array of what API versions we understand
protected static final String[] API_VERSIONS = {"1"}; // I assume we might encounter arbitrary version "numbers"
// Some API pieces we want to know about
private static final String API_TERM_SERVICES = "services";
private static final String API_TERM_NAME = "name";
private static final String API_TERM_DEFAULT_LANGUAGE = "default_language";
protected static final String[] API_EIP_TYPES = {"openvpn"};
private static final String PREFS_EIP_NAME = null;
// What, no individual fields?! We're going to gamble on org.json.JSONObject and JSONArray
// Supporting multiple API versions will probably break this paradigm,
// Forcing me to write a real constructor and rewrite getters/setters
// Also will refactor if i'm instantiating the same local variables all the time
/**
*
*/
private Provider() {}
protected static Provider getInstance(){
if(instance==null){
instance = new Provider();
}
return instance;
}
protected void init(Activity activity) {
// Load our preferences from SharedPreferences
// If there's nothing there, we will end up returning a rather empty object
// to whoever called getInstance() and they can run the First Run Wizard
//preferences = context.getgetPreferences(0); // 0 == MODE_PRIVATE, but we don't extend Android's classes...
// Load SharedPreferences
preferences = activity.getSharedPreferences(ConfigHelper.PREFERENCES_KEY,Context.MODE_PRIVATE);
// Inflate our provider.json data
try {
definition = new JSONObject( preferences.getString("provider", "") );
} catch (JSONException e) {
// TODO: handle exception
// FIXME!! We want "real" data!!
}
}
protected String getName(){
// Should we pass the locale in, or query the system here?
String lang = Locale.getDefault().getLanguage();
String name = "Null"; // Should it actually /be/ null, for error conditions?
try {
name = definition.getJSONObject(API_TERM_NAME).getString(lang);
} catch (JSONException e) {
// TODO: Nesting try/catch blocks? Crazy
// Maybe you should actually handle exception?
try {
name = definition.getJSONObject(API_TERM_NAME).getString( definition.getString(API_TERM_DEFAULT_LANGUAGE) );
} catch (JSONException e2) {
// TODO: Will you handle the exception already?
}
}
return name;
}
protected String getDescription(){
String lang = Locale.getDefault().getLanguage();
String desc = null;
try {
desc = definition.getJSONObject("description").getString(lang);
} catch (JSONException e) {
// TODO: handle exception!!
try {
desc = definition.getJSONObject("description").getString( definition.getString("default_language") );
} catch (JSONException e2) {
// TODO: i can't believe you're doing it again!
}
}
return desc;
}
protected boolean hasEIP() {
JSONArray services = null;
try {
services = definition.getJSONArray(API_TERM_SERVICES); // returns ["openvpn"]
} catch (Exception e) {
// TODO: handle exception
}
for (int i=0;i<API_EIP_TYPES.length;i++){
try {
// Walk the EIP types array looking for matches in provider's service definitions
if ( Arrays.asList(API_EIP_TYPES).contains( services.getString(i) ) )
return true;
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return false;
}
protected String getEIPType() {
// FIXME!!!!! We won't always be providing /only/ OpenVPN, will we?
// This will have to hook into some saved choice of EIP transport
if ( instance.hasEIP() )
return "OpenVPN";
else
return null;
}
protected JSONObject getEIP() {
// FIXME!!!!! We won't always be providing /only/ OpenVPN, will we?
// This will have to hook into some saved choice of EIP transport, cluster, gateway
// with possible "choose at random" preference
if ( instance.hasEIP() ){
// TODO Might need an EIP class, but we've only got OpenVPN type right now,
// and only one gateway for our only provider...
// TODO We'll try to load from preferences, have to call ProviderAPI if we've got nothin...
JSONObject eipObject = null;
try {
eipObject = new JSONObject( preferences.getString(PREFS_EIP_NAME, "") );
} catch (JSONException e) {
// TODO ConfigHelper.rescueJSON()
// Still nothing?
// TODO ProviderAPI.getEIP()
e.printStackTrace();
}
return eipObject;
} else
return null;
}
}
|
