lib/android/shared_preferences/shared_preferences_api10.nit

   1 # This file is part of NIT (http://www.nitlanguage.org).
   2 #
   3 # Copyright 2014 Frédéric Vachon <fredvac@gmail.com>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # Services to save/load data using `android.content.SharedPreferences` for the android platform
  18 module shared_preferences_api10
  19
  20 import native_app_glue
  21 import serialization
  22 private import json_serialization
  23
  24 in "Java" `{
  25         import android.content.SharedPreferences;
  26         import android.content.Context;
  27         import android.app.Activity;
  28         import java.util.Map;
  29         import java.util.Iterator;
  30         import java.lang.ClassCastException;
  31         import java.lang.NullPointerException;
  32 `}
  33
  34 extern class NativeSharedPreferences in "Java" `{ android.content.SharedPreferences `}
  35         super JavaObject
  36         redef type SELF: NativeSharedPreferences
  37
  38         fun contains(key: JavaString): Bool in "Java" `{ return recv.contains(key); `}
  39         fun get_all: HashMap[JavaString, JavaObject] import HashMap[JavaString, JavaObject],
  40                 HashMap[JavaString, JavaObject].[]= in "Java" `{
  41                 Map<String, ?> java_map = null;
  42                 int nit_hashmap = new_HashMap_of_JavaString_JavaObject();
  43                 try {
  44                         java_map = recv.getAll();
  45                 } catch (NullPointerException e) {
  46                         return nit_hashmap;
  47                 }
  48
  49                 for (Map.Entry<String, ?> entry: java_map.entrySet())
  50                         HashMap_of_JavaString_JavaObject__index_assign(nit_hashmap,
  51                                 entry.getKey(), entry.getValue());
  52
  53                 return nit_hashmap;
  54         `}
  55         fun get_boolean(key: JavaString, def_value: Bool): Bool in "Java" `{
  56                 boolean return_value;
  57                 try {
  58                         return_value = recv.getBoolean(key, def_value);
  59                 } catch (ClassCastException e) {
  60                         return def_value;
  61                 }
  62
  63                 return return_value;
  64         `}
  65         fun get_float(key: JavaString, def_value: Float): Float in "Java" `{
  66                 float return_value;
  67                 try {
  68                         return_value = recv.getFloat(key, (float) def_value);
  69                 } catch (ClassCastException e) {
  70                         return def_value;
  71                 }
  72
  73                 return return_value;
  74         `}
  75         fun get_int(key: JavaString, def_value: Int): Int in "Java" `{
  76                 int return_value;
  77                 try {
  78                         return_value = recv.getInt(key, (int)def_value);
  79                 } catch (ClassCastException e) {
  80                         return def_value;
  81                 }
  82
  83                 return return_value;
  84         `}
  85         fun get_long(key: JavaString, def_value: Int): Int in "Java" `{
  86                 long return_value;
  87                 try {
  88                         return_value = recv.getLong(key, def_value);
  89                 } catch (ClassCastException e) {
  90                         return def_value;
  91                 }
  92
  93                 return (int) return_value;
  94         `}
  95         fun get_string(key: JavaString, def_value: JavaString): JavaString in "Java" `{
  96                 String return_value = null;
  97                 try {
  98                         return_value = recv.getString(key, def_value);
  99                 } catch (ClassCastException e) {
 100                         return def_value;
 101                 }
 102
 103                 return return_value;
 104         `}
 105 end
 106
 107 extern class NativeSharedPreferencesEditor in "Java" `{ android.content.SharedPreferences$Editor `}
 108         super JavaObject
 109         redef type SELF: NativeSharedPreferencesEditor
 110
 111         fun clear: NativeSharedPreferencesEditor in "Java" `{ return recv.clear(); `}
 112         fun commit: Bool in "Java" `{ return recv.commit(); `}
 113         fun put_boolean(key: JavaString, value: Bool ): NativeSharedPreferencesEditor in "Java" `{
 114                 return recv.putBoolean (key, value);
 115         `}
 116         fun put_float(key: JavaString, value: Float): NativeSharedPreferencesEditor in "Java" `{
 117                 return recv.putFloat(key, (float) value);
 118         `}
 119         fun put_int(key: JavaString, value: Int): NativeSharedPreferencesEditor in "Java" `{
 120                 return recv.putInt(key, (int)value);
 121         `}
 122         fun put_long(key: JavaString, value: Int): NativeSharedPreferencesEditor in "Java" `{
 123                 return recv.putLong(key, value);
 124         `}
 125         fun put_string(key: JavaString, value: JavaString): NativeSharedPreferencesEditor in "Java" `{
 126                 return recv.putString(key, value);
 127         `}
 128         fun remove(key: JavaString): NativeSharedPreferencesEditor in "Java" `{
 129                 return recv.remove(key);
 130         `}
 131 end
 132
 133 # Provides services to save and load data for the android platform
 134 class SharedPreferences
 135         protected var context: NativeActivity
 136         protected var shared_preferences: NativeSharedPreferences
 137         protected var editor: NativeSharedPreferencesEditor
 138
 139         # Automatically commits every saving/removing instructions (`true` by default)
 140         var auto_commit = true
 141
 142         protected init(app: App, file_name: String, mode: Int)
 143         do
 144                 self.context = app.native_activity
 145                 sys.jni_env.push_local_frame(1)
 146                 setup(file_name.to_java_string, mode)
 147                 sys.jni_env.pop_local_frame
 148         end
 149
 150         # Restricts file access to the current application
 151         init privately(app: App, file_name: String)
 152         do
 153                 self.init(app, file_name, private_mode)
 154         end
 155
 156         # File access mode
 157         private fun private_mode: Int in "Java" `{ return Context.MODE_PRIVATE; `}
 158
 159         private fun set_vars(shared_pref: NativeSharedPreferences, editor: NativeSharedPreferencesEditor)
 160         do
 161                 self.shared_preferences = shared_pref.new_global_ref
 162                 self.editor = editor.new_global_ref
 163         end
 164
 165         private fun setup(file_name: JavaString, mode: Int) import context, set_vars in "Java" `{
 166                 Activity context = (Activity) SharedPreferences_context(recv);
 167                 SharedPreferences sp;
 168
 169                 // Uses default SharedPreferences if file_name is an empty String
 170                 if (file_name.equals("")) {
 171                         sp = context.getPreferences((int)mode);
 172                 } else {
 173                         sp = context.getSharedPreferences(file_name, (int)mode);
 174                 }
 175
 176                 SharedPreferences.Editor editor = sp.edit();
 177
 178                 SharedPreferences_set_vars(recv, sp, editor);
 179         `}
 180
 181         private fun commit_if_auto do if auto_commit then self.commit
 182
 183         # Returns true if there's an entry corresponding the given key
 184         fun has(key: String): Bool
 185         do
 186                 sys.jni_env.push_local_frame(2)
 187                 var return_value = shared_preferences.contains(key.to_java_string)
 188                 sys.jni_env.pop_local_frame
 189                 return return_value
 190         end
 191
 192         # Returns a `HashMap` containing all entries or `null` if there's no entries
 193         #
 194         # User has to manage local stack deallocation himself
 195         #
 196         # Example :
 197         # ~~~
 198         # var foo = new HashMap[JavaString, JavaObject]
 199         # # ...
 200         # for key, value in foo do
 201         #      key.delete_local_ref
 202         #      value.delete_local_ref
 203         # end
 204         # ~~~
 205         # *You should use Nit getters instead and get each value one by one*
 206         fun all: nullable HashMap[JavaString, JavaObject]
 207         do
 208                 var hashmap = shared_preferences.get_all
 209                 if hashmap.is_empty then return null
 210                 return hashmap
 211         end
 212
 213         # Returns the `Bool` value corresponding the given key or `def_value` if none
 214         # or if the value isn't of correct type
 215         fun bool(key: String, def_value: Bool): Bool
 216         do
 217                 sys.jni_env.push_local_frame(2)
 218                 var return_value = shared_preferences.get_boolean(key.to_java_string, def_value)
 219                 sys.jni_env.pop_local_frame
 220                 return return_value
 221         end
 222
 223         # Returns the `Float` value corresponding the given key or `def_value` if none
 224         # or if the value isn't of correct type
 225         fun float(key: String, def_value: Float): Float
 226         do
 227                 sys.jni_env.push_local_frame(2)
 228                 var return_value = shared_preferences.get_float(key.to_java_string, def_value)
 229                 sys.jni_env.pop_local_frame
 230                 return return_value
 231         end
 232
 233         # Returns the `Int` value corresponding the given key or `def_value` if none
 234         # or if the value isn't of correct type
 235         # Be aware of possible `def_value` integer overflow as the Nit `Int` corresponds
 236         # to Java `long`
 237         fun int(key: String, def_value: Int): Int
 238         do
 239                 sys.jni_env.push_local_frame(2)
 240                 var return_value = shared_preferences.get_int(key.to_java_string, def_value)
 241                 sys.jni_env.pop_local_frame
 242                 return return_value
 243         end
 244
 245         # Returns the `Int` value corresponding the given key or `def_value` if none
 246         # or if the value isn't of correct type
 247         # Calls `getLong(key, value)` java method
 248         # Nit `Int` is equivalent to Java `long` so that no integer overflow will occur
 249         fun long(key: String, def_value: Int): Int
 250         do
 251                 sys.jni_env.push_local_frame(2)
 252                 var return_value = shared_preferences.get_long(key.to_java_string, def_value)
 253                 sys.jni_env.pop_local_frame
 254                 return return_value
 255         end
 256
 257         # Returns the `String` value corresponding the given key or `def_value` if none
 258         # or if the value isn't of correct type
 259         fun string(key: String, def_value: String): String
 260         do
 261                 sys.jni_env.push_local_frame(3)
 262                 var java_return_value = shared_preferences.get_string(key.to_java_string,
 263                         def_value.to_java_string)
 264                 var nit_return_value = java_return_value.to_s
 265                 sys.jni_env.pop_local_frame
 266                 return nit_return_value
 267         end
 268
 269         # Clears all the dictionnary entries in the specified file or the default file
 270         # if none specified at instanciation
 271         # Returns `self` allowing fluent programming
 272         fun clear: SharedPreferences
 273         do
 274                 editor.clear
 275                 commit_if_auto
 276                 return self
 277         end
 278
 279         # If auto_commit is `false`, has to be called to save the data to persistant memory
 280         fun commit: Bool
 281         do
 282                 sys.jni_env.push_local_frame(1)
 283                 var return_value = editor.commit
 284                 sys.jni_env.pop_local_frame
 285                 return return_value
 286         end
 287
 288         # Set a key-value pair using a `Bool` value
 289         # Returns `self` allowing fluent programming
 290         fun add_bool(key: String, value: Bool ): SharedPreferences
 291         do
 292                 sys.jni_env.push_local_frame(1)
 293                 editor.put_boolean(key.to_java_string, value)
 294                 sys.jni_env.pop_local_frame
 295                 commit_if_auto
 296                 return self
 297         end
 298
 299         # Set a key-value pair using a `Float` value
 300         # Returns `self` allowing fluent programming
 301         #
 302         # Be aware of possible loss of precision as Nit `Float` corresponds to Java `double`
 303         # and the methods stores a Java `float`
 304         fun add_float(key: String, value: Float): SharedPreferences
 305         do
 306                 sys.jni_env.push_local_frame(1)
 307                 editor.put_float(key.to_java_string, value)
 308                 sys.jni_env.pop_local_frame
 309                 commit_if_auto
 310                 return self
 311         end
 312
 313         # Set a key-value pair using a `Int` type value
 314         # Returns `self` allowing fluent programming
 315         #
 316         # Be aware of possible integer overflow as the Nit `Int` corresponds to Java `long`
 317         # and the methods stores a Java `int`
 318         # *You might want to use add_long instead*
 319         fun add_int(key: String, value: Int): SharedPreferences
 320         do
 321                 sys.jni_env.push_local_frame(1)
 322                 editor.put_int(key.to_java_string, value)
 323                 sys.jni_env.pop_local_frame
 324                 commit_if_auto
 325                 return self
 326         end
 327
 328         # Set a key-value pair using a `Int` type value
 329         # Returns `self` allowing fluent programming
 330         fun add_long(key: String, value: Int): SharedPreferences
 331         do
 332                 sys.jni_env.push_local_frame(1)
 333                 editor.put_long(key.to_java_string, value)
 334                 sys.jni_env.pop_local_frame
 335                 commit_if_auto
 336                 return self
 337         end
 338
 339         # Set a key-value pair using a `String` type value
 340         # Returns `self` allowing fluent programming
 341         fun add_string(key: String, value: String): SharedPreferences
 342         do
 343                 sys.jni_env.push_local_frame(2)
 344                 editor.put_string(key.to_java_string, value.to_java_string)
 345                 sys.jni_env.pop_local_frame
 346                 commit_if_auto
 347                 return self
 348         end
 349
 350         # Removes the corresponding entry in the file
 351         # Returns `self` allowing fluent programming
 352         fun remove(key: String): SharedPreferences
 353         do
 354                 sys.jni_env.push_local_frame(1)
 355                 editor.remove(key.to_java_string)
 356                 sys.jni_env.pop_local_frame
 357                 commit_if_auto
 358                 return self
 359         end
 360
 361         # Deallocate global references allocated by the SharedPreferences instance
 362         fun destroy
 363         do
 364                 self.shared_preferences.delete_global_ref
 365                 self.editor.delete_global_ref
 366         end
 367
 368         # Store `value` as a serialized Json string
 369         fun []=(key: String, value: nullable Serializable)
 370         do
 371                 var serialized_string = new StringOStream
 372                 var serializer = new JsonSerializer(serialized_string)
 373                 serializer.serialize(value)
 374
 375                 add_string(key, serialized_string.to_s)
 376                 commit_if_auto
 377         end
 378
 379         # Retrieve an `Object` stored via `[]=` function
 380         #
 381         # Returns `null` if there's no serialized object corresponding to the given key
 382         # Make sure that the serialized object is `auto_serializable` or that it redefines
 383         # the appropriate methods. Refer to `Serializable` documentation for further details
 384         fun [](key: String): nullable Object
 385         do
 386                 var serialized_string = self.string(key, "")
 387
 388                 if serialized_string == "" then return null
 389
 390                 var deserializer = new JsonDeserializer(serialized_string)
 391                 return deserializer.deserialize
 392         end
 393 end
 394
 395 redef class App
 396         fun shared_preferences: SharedPreferences is cached do
 397                 return new SharedPreferences.privately(self, "")
 398         end
 399 end