lib/android/intent/intent_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 allowing to launch activities and start/stop services using
  18 # `android.content.Intent` for the android platform
  19 module intent_api10
  20
  21 import dalvik
  22 import android::bundle
  23 import serialization
  24 private import json
  25
  26 in "Java" `{
  27         import android.content.Intent;
  28         import android.net.Uri;
  29         import android.graphics.Rect;
  30         import java.util.Set;
  31         import java.util.ArrayList;
  32         import nit.app.NitObject;
  33 `}
  34
  35 extern class NativeIntent in "Java" `{ android.content.Intent `}
  36         super JavaObject
  37
  38         new in "Java" `{ return new Intent(); `}
  39
  40         fun add_category(category: JavaString) in "Java" `{ self.addCategory(category); `}
  41         fun add_flags(flags: Int) in "Java" `{ self.addFlags((int)flags); `}
  42         fun filter_equals(other: NativeIntent): Bool in "Java" `{
  43                 return self.filterEquals(other);
  44         `}
  45         fun action: JavaString in "Java" `{ return self.getAction(); `}
  46         fun boolean_array_extra(name: JavaString): Array[Bool] import Array[Bool],
  47           Array[Bool].push in "Java" `{
  48                 boolean[] java_array = self.getBooleanArrayExtra(name);
  49                 NitObject nit_array = new_Array_of_Bool();
  50
  51                 for(int i=0; i < java_array.length; ++i)
  52                         Array_of_Bool_push(nit_array, java_array[i]);
  53
  54                 return nit_array;
  55         `}
  56         fun boolean_extra(name: JavaString, def_value: Bool): Bool in "Java" `{
  57                 return self.getBooleanExtra(name, def_value);
  58         `}
  59         fun byte_array_extra(name: JavaString): Array[Int] import Array[Int],
  60           Array[Int].add in "Java" `{
  61                 byte[] java_array = self.getByteArrayExtra(name);
  62                 NitObject nit_array = new_Array_of_Int();
  63
  64                 for (int i=0; i < java_array.length; ++i)
  65                         Array_of_Int_add(nit_array, java_array[i]);
  66
  67                 return nit_array;
  68         `}
  69         fun byte_extra(name: JavaString, def_value: Int): Int in "Java" `{
  70                 return (int) self.getByteExtra(name, (byte) def_value);
  71         `}
  72         # FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
  73         fun char_array_extra(name: JavaString): Array[Char] import Array[Char],
  74           Array[Char].add in "Java" `{
  75                 char[] java_array = self.getCharArrayExtra(name);
  76                 NitObject nit_array = new_Array_of_Char();
  77
  78                 for (int i = 0; i < java_array.length; ++i)
  79                         Array_of_Char_add(nit_array, java_array[i]);
  80
  81                 return nit_array;
  82         `}
  83         # FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
  84         fun char_extra(name: JavaString, def_value: Char): Char in "Java" `{
  85                 return (int)self.getCharExtra(name, (char)def_value);
  86         `}
  87         fun char_sequence_array_extra(name: JavaString): Array[String]
  88           import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
  89                 CharSequence[] java_array = self.getCharSequenceArrayExtra(name);
  90                 NitObject nit_array = new_StringCopyArray();
  91
  92                 for (int i = 0; i < java_array.length; ++i)
  93                         StringCopyArray_add(nit_array, (String) java_array[i]);
  94
  95                 return StringCopyArray_collection(nit_array);
  96         `}
  97         fun char_sequence_array_list_extra(name: JavaString): Array[String]
  98           import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
  99                 ArrayList<CharSequence> java_array = self.getCharSequenceArrayListExtra(name);
 100                 NitObject nit_array = new_StringCopyArray();
 101
 102                 if (java_array == null) return nit_array;
 103
 104                 for (CharSequence element: java_array)
 105                         StringCopyArray_add(nit_array, (String) element);
 106
 107                 return StringCopyArray_collection(nit_array);
 108         `}
 109         fun char_sequence_extra(name: JavaString): JavaString in "Java" `{
 110                 return (String) self.getCharSequenceExtra(name);
 111         `}
 112         fun categories: HashSet[String] import StringCopyHashSet,
 113           StringCopyHashSet.add, StringCopyHashSet.collection  in "Java" `{
 114                 Set<String> java_set = self.getCategories();
 115                 NitObject nit_hashset = new_StringCopyHashSet();
 116
 117                 if (java_set == null) return nit_hashset;
 118
 119                 for (String element: java_set)
 120                         StringCopyHashSet_add(nit_hashset, element);
 121
 122                 return StringCopyHashSet_collection(nit_hashset);
 123         `}
 124         # Returns the Uri as an encoded String
 125         fun data: JavaString in "Java" `{ return self.getDataString(); `}
 126         fun double_array_extra(name: JavaString): Array[Float] import Array[Float],
 127           Array[Float].push in "Java" `{
 128                 double[] java_array = self.getDoubleArrayExtra(name);
 129                 NitObject nit_array = new_Array_of_Float();
 130
 131                 for(int i=0; i < java_array.length; ++i)
 132                         Array_of_Float_push(nit_array, java_array[i]);
 133
 134                 return nit_array;
 135         `}
 136         fun double_extra(name: JavaString, def_value: Float): Float in "Java" `{
 137                 return self.getDoubleExtra(name, def_value);
 138         `}
 139         fun flags: Int in "Java" `{ return self.getFlags(); `}
 140         fun float_array_extra(name: JavaString): Array[Float] import Array[Float],
 141           Array[Float].push in "Java" `{
 142                 float[] java_array = self.getFloatArrayExtra(name);
 143                 NitObject nit_array = new_Array_of_Float();
 144
 145                 for(int i=0; i < java_array.length; ++i)
 146                         Array_of_Float_push(nit_array, java_array[i]);
 147
 148                 return nit_array;
 149         `}
 150         fun float_extra(name: JavaString, def_value: Float): Float in "Java" `{
 151                 return self.getFloatExtra(name, (float) def_value);
 152         `}
 153         fun int_array_extra(name: JavaString): Array[Int] import Array[Int],
 154           Array[Int].push in "Java" `{
 155                 int[] java_array = self.getIntArrayExtra(name);
 156                 NitObject nit_array = new_Array_of_Int();
 157
 158                 for(int i=0; i < java_array.length; ++i)
 159                         Array_of_Int_push(nit_array, java_array[i]);
 160
 161                 return nit_array;
 162         `}
 163         fun int_extra(name: JavaString, def_value: Int): Int in "Java" `{
 164                 return self.getIntExtra(name, (int)def_value);
 165         `}
 166         fun long_array_extra(name: JavaString): Array[Int] import Array[Int],
 167           Array[Int].push in "Java" `{
 168                 long[] java_array = self.getLongArrayExtra(name);
 169                 NitObject nit_array = new_Array_of_Int();
 170
 171                 for(int i=0; i < java_array.length; ++i)
 172                         Array_of_Int_push(nit_array, (int) java_array[i]);
 173
 174                 return nit_array;
 175         `}
 176         fun long_extra(name: JavaString, def_value: Int): Int in "Java" `{
 177                 return (int) self.getLongExtra(name, def_value);
 178         `}
 179         fun get_package: JavaString in "Java" `{ return self.getPackage(); `}
 180         fun scheme: JavaString in "Java" `{ return self.getScheme(); `}
 181         fun short_array_extra(name: JavaString): Array[Int] import Array[Int],
 182           Array[Int].push in "Java" `{
 183                 short[] java_array = self.getShortArrayExtra(name);
 184                 NitObject nit_array = new_Array_of_Int();
 185
 186                 for(int i=0; i < java_array.length; ++i)
 187                         Array_of_Int_push(nit_array, (int) java_array[i]);
 188
 189                 return nit_array;
 190         `}
 191         fun short_extra(name: JavaString, def_value: Int): Int in "Java" `{
 192                 return self.getShortExtra(name, (short) def_value);
 193         `}
 194         fun string_array_extra(name: JavaString): Array[String]
 195           import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
 196                 String[] java_array = self.getStringArrayExtra(name);
 197                 NitObject nit_array = new_StringCopyArray();
 198
 199                 for(int i=0; i < java_array.length; ++i)
 200                         StringCopyArray_add(nit_array, java_array[i]);
 201
 202                 return StringCopyArray_collection(nit_array);
 203         `}
 204         fun string_array_list_extra(name: JavaString): Array[String]
 205           import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
 206                 ArrayList<String> java_array = self.getStringArrayListExtra(name);
 207                 NitObject nit_array = new_StringCopyArray();
 208
 209                 for (String element: java_array)
 210                         StringCopyArray_add(nit_array, element);
 211
 212                 return StringCopyArray_collection(nit_array);
 213         `}
 214         fun string_extra(name: JavaString): JavaString in "Java" `{
 215                 String return_value = self.getStringExtra(name);
 216                 if (return_value == null) return "";
 217
 218                 return return_value;
 219         `}
 220         fun get_type: JavaString in "Java" `{ return self.getType(); `}
 221         fun has_category(category: JavaString): Bool in "Java" `{
 222                 return self.hasCategory(category);
 223         `}
 224         fun has_extra(extra: JavaString): Bool in "Java" `{ return self.hasExtra(extra); `}
 225         fun has_file_descriptors: Bool in "Java" `{ return self.hasFileDescriptors(); `}
 226         fun add_extra_double(name: JavaString, value: Float): NativeIntent in "Java" `{
 227                 return self.putExtra(name, value);
 228         `}
 229         fun add_extra_array_of_double(name: JavaString, value: Array[Float]): NativeIntent
 230           import Array[Float].length, Array[Float].[] in "Java" `{
 231                 double[] java_array = new double[(int)Array_of_Float_length(value)];
 232
 233                 for (int i=0; i < java_array.length; ++i)
 234                         java_array[i] = Array_of_Float__index(value, i);
 235
 236                 return self.putExtra(name, java_array);
 237         `}
 238         # FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
 239         fun add_extra_char(name: JavaString, value: Char): NativeIntent in "Java" `{
 240                 return self.putExtra(name, value);
 241         `}
 242         # FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
 243         fun add_extra_array_of_char(name: JavaString, value: Array[Char]): NativeIntent
 244           import Array[Char].length, Array[Char].[] in "Java" `{
 245                 char[] java_array = new char[(int)Array_of_Char_length(value)];
 246
 247                 for (int i=0; i < java_array.length; ++i)
 248                         java_array[i] = (char)Array_of_Char__index(value, i);
 249
 250                 return self.putExtra(name, java_array);
 251         `}
 252         fun add_extra_char_sequence(name: JavaString, value: JavaString): NativeIntent
 253           in "Java" `{
 254                 return self.putExtra(name, value);
 255         `}
 256         fun add_extra_array_of_char_sequence(name: JavaString, value: Array[JavaString]):
 257           NativeIntent import Array[JavaString].length, Array[JavaString].[] in "Java" `{
 258                 CharSequence[] java_array = new CharSequence[(int)Array_of_JavaString_length(value)];
 259
 260                 for (int i=0; i < java_array.length; ++i)
 261                         java_array[i] = Array_of_JavaString__index(value, i);
 262
 263                 return self.putExtra(name, java_array);
 264         `}
 265         fun add_extra_bundle(name: JavaString, value: NativeBundle): NativeIntent
 266           in "Java" `{
 267                 return self.putExtra(name, value);
 268         `}
 269         fun add_extra_int(name: JavaString, value: Int): NativeIntent in "Java" `{
 270                 return self.putExtra(name, value);
 271         `}
 272         fun add_extra_array_of_int(name: JavaString, value: Array[Int]): NativeIntent
 273           import Array[Int].length, Array[Int].[] in "Java" `{
 274                 int[] java_array = new int[(int)Array_of_Int_length(value)];
 275
 276                 for (int i=0; i < java_array.length; ++i)
 277                         java_array[i] = (int)Array_of_Int__index(value, i);
 278
 279                 return self.putExtra(name, java_array);
 280         `}
 281         fun add_extra_array_list_of_int(name: JavaString, value: Array[Int]): NativeIntent
 282           import Array[Int].length, Array[Int].[] in "Java" `{
 283                 int length = (int)Array_of_Int_length(value);
 284                 ArrayList<Integer> java_array = new ArrayList<Integer>(length);
 285
 286                 for (int i=0; i < length; ++i)
 287                         java_array.add((int)Array_of_Int__index(value, i));
 288
 289                 return self.putExtra(name, java_array);
 290         `}
 291         fun add_extra_byte(name: JavaString, value: Int): NativeIntent in "Java" `{
 292                 return self.putExtra(name, (byte) value);
 293         `}
 294         fun add_extra_array_of_byte(name: JavaString, value: Int): NativeIntent in "Java" `{
 295                 return self.putExtra(name, (byte) value);
 296         `}
 297         fun add_extra_long(name: JavaString, value: Int): NativeIntent in "Java" `{
 298                 return self.putExtra(name, value);
 299         `}
 300         fun add_extra_array_of_long(name: JavaString, value: Array[Int]): NativeIntent
 301           import Array[Int].length, Array[Int].[] in "Java" `{
 302                 long[] java_array = new long[(int)Array_of_Int_length(value)];
 303
 304                 for (int i=0; i < java_array.length; ++i)
 305                         java_array[i] = Array_of_Int__index(value, i);
 306
 307                 return self.putExtra(name, java_array);
 308         `}
 309         fun add_extra_float(name: JavaString, value: Float): NativeIntent in "Java" `{
 310                 return self.putExtra(name, value);
 311         `}
 312         fun add_extra_array_of_float(name: JavaString, value: Array[Float]): NativeIntent
 313           import Array[Float].length, Array[Float].[] in "Java" `{
 314                 float[] java_array = new float[(int)Array_of_Float_length(value)];
 315
 316                 for (int i=0; i < java_array.length; ++i)
 317                         java_array[i] = (float) Array_of_Float__index(value, i);
 318
 319                 return self.putExtra(name, java_array);
 320         `}
 321         fun add_extra_string(name: JavaString, value: JavaString): NativeIntent in "Java" `{
 322                 return self.putExtra(name, value);
 323         `}
 324         fun add_extra_array_of_string(name: JavaString, value: Array[JavaString]): NativeIntent
 325           import Array[JavaString].length, Array[JavaString].[] in "Java" `{
 326                 String[] java_array = new String[(int)Array_of_JavaString_length(value)];
 327
 328                 for (int i=0; i < java_array.length; ++i)
 329                         java_array[i] = Array_of_JavaString__index(value, i);
 330
 331                 return self.putExtra(name, java_array);
 332         `}
 333         fun add_extra_array_list_of_string(name: JavaString, value: Array[JavaString]): NativeIntent
 334           import Array[JavaString].length, Array[JavaString].[] in "Java" `{
 335                 int length = (int)Array_of_JavaString_length(value);
 336                 ArrayList<String> java_array = new ArrayList<String>(length);
 337
 338                 for (int i=0; i < length; ++i) {
 339                         java_array.add(Array_of_JavaString__index(value, i));
 340                 }
 341
 342                 return self.putExtra(name, java_array);
 343         `}
 344         fun add_extra_bool(name: JavaString, value: Bool): NativeIntent in "Java" `{
 345                 return self.putExtra(name, value);
 346         `}
 347         fun add_extra_array_of_bool(name: JavaString, value: Array[Bool]): NativeIntent
 348           import Array[Bool].length, Array[Bool].[] in "Java" `{
 349                 boolean[] java_array = new boolean[(int)Array_of_Bool_length(value)];
 350
 351                 for (int i=0; i < java_array.length; ++i)
 352                         java_array[i] = Array_of_Bool__index(value, i);
 353
 354                 return self.putExtra(name, java_array);
 355         `}
 356         fun add_extra_short(name: JavaString, value: Int): NativeIntent in "Java" `{
 357                 return self.putExtra(name, value);
 358         `}
 359         fun add_extra_array_of_short(name: JavaString, value: Array[Int]): NativeIntent
 360           import Array[Int].length, Array[Int].[] in "Java" `{
 361                 short[] java_array = new short[(int)Array_of_Int_length(value)];
 362
 363                 for (int i=0; i < java_array.length; ++i)
 364                         java_array[i] = (short) Array_of_Int__index(value, i);
 365
 366                 return self.putExtra(name, java_array);
 367         `}
 368         fun copy_extras(src: NativeIntent): NativeIntent in "Java" `{ return self.putExtras(src); `}
 369         fun add_extras(src: NativeBundle): NativeIntent in "Java" `{ return self.putExtras(src); `}
 370         fun remove_category(category: JavaString) in "Java" `{ self.removeCategory(category); `}
 371         fun remove_extra(name: JavaString) in "Java" `{ self.removeExtra(name); `}
 372         fun replace_extras(src: NativeIntent): NativeIntent in "Java" `{
 373                 return self.replaceExtras(src);
 374         `}
 375         fun resolve_activity(pm: NativePackageManager): NativeComponentName in "Java" `{
 376                 return self.resolveActivity(pm);
 377         `}
 378         fun resolve_type(context: NativeActivity): JavaString in "Java" `{
 379                 return self.resolveType(context);
 380         `}
 381         fun action=(action: JavaString): NativeIntent in "Java" `{ return self.setAction(action); `}
 382         fun class_=(package_context: NativeActivity, class_name: JavaString): NativeIntent
 383           in "Java" `{
 384                 Class<?> java_class = null;
 385                 try {
 386                         java_class = Class.forName(class_name);
 387                 } catch (Exception e) {
 388                         e.getStackTrace();
 389                 }
 390                 return self.setClass(package_context, java_class);
 391         `}
 392         fun class_name=(package_context: NativeActivity, class_name: JavaString): NativeIntent
 393           in "Java" `{
 394                 return self.setClassName(package_context, class_name);
 395         `}
 396         fun set_class_name(package_name: JavaString, class_name: JavaString): NativeIntent
 397           in "Java" `{
 398                 return self.setClassName(package_name, class_name);
 399         `}
 400         fun data=(data_uri: JavaString): NativeIntent in "Java" `{
 401                 return self.setData(Uri.parse(data_uri));
 402         `}
 403         fun data_and_type=(data_uri: JavaString, type_: JavaString): NativeIntent in "Java" `{
 404                 return self.setDataAndType(Uri.parse(data_uri), type_);
 405         `}
 406         fun flags=(flags: Int): NativeIntent in "Java" `{ return self.setFlags((int)flags); `}
 407         fun package_name=(package_name: JavaString): NativeIntent in "Java" `{
 408                 return self.setPackage(package_name);
 409         `}
 410         fun source_bounds=(left, top, right, bottom: Int) in "Java" `{
 411                 self.setSourceBounds(new Rect((int)left, (int)top, (int)right, (int)bottom));
 412         `}
 413         fun mime_type=(mime_type: JavaString): NativeIntent in "Java" `{
 414                 return self.setType(mime_type);
 415         `}
 416         fun to_native_s: JavaString in "Java" `{ return self.toString(); `}
 417         fun to_uri(flags: Int): JavaString in "Java" `{ return self.toUri((int)flags); `}
 418
 419         # HACK for bug #845
 420         redef fun new_global_ref import sys, Sys.jni_env `{
 421                 Sys sys = NativeIntent_sys(self);
 422                 JNIEnv *env = Sys_jni_env(sys);
 423                 return (*env)->NewGlobalRef(env, self);
 424         `}
 425 end
 426
 427 extern class NativePackageManager in "Java" `{ android.content.pm.PackageManager `}
 428 end
 429
 430 extern class NativeComponentName in "Java" `{ android.content.ComponentName `}
 431 end
 432
 433 # Contains a set of actions that can be performed by the intent
 434 # Designed to be used with the `intent_action` function
 435 # Example : `intent_action.main`
 436 #
 437 # For further details on actions, refer to Android Intent documentation
 438 class Action
 439
 440         # Standard Activity Action
 441         fun main: JavaString in "Java" `{ return Intent.ACTION_MAIN; `}
 442         fun view: JavaString in "Java" `{ return Intent.ACTION_VIEW; `}
 443         fun attach_data: JavaString in "Java" `{ return Intent.ACTION_ATTACH_DATA; `}
 444         fun edit: JavaString in "Java" `{ return Intent.ACTION_EDIT; `}
 445         fun pick: JavaString in "Java" `{ return Intent.ACTION_PICK; `}
 446         fun chooser: JavaString in "Java" `{ return Intent.ACTION_CHOOSER; `}
 447         fun get_content: JavaString in "Java" `{ return Intent.ACTION_GET_CONTENT; `}
 448         fun dial: JavaString in "Java" `{ return Intent.ACTION_DIAL; `}
 449         fun call: JavaString in "Java" `{ return Intent.ACTION_CALL; `}
 450         fun send: JavaString in "Java" `{ return Intent.ACTION_SEND; `}
 451         fun sent_to: JavaString in "Java" `{ return Intent.ACTION_SENDTO; `}
 452         fun answer: JavaString in "Java" `{ return Intent.ACTION_ANSWER; `}
 453         fun insert: JavaString in "Java" `{ return Intent.ACTION_INSERT; `}
 454         fun delete: JavaString in "Java" `{ return Intent.ACTION_DELETE; `}
 455         fun run: JavaString in "Java" `{ return Intent.ACTION_RUN; `}
 456         fun sync: JavaString in "Java" `{ return Intent.ACTION_SYNC; `}
 457         fun pick_activity: JavaString in "Java" `{ return Intent.ACTION_PICK_ACTIVITY; `}
 458         fun search: JavaString in "Java" `{ return Intent.ACTION_SEARCH; `}
 459         fun web_search: JavaString in "Java" `{ return Intent.ACTION_WEB_SEARCH; `}
 460         fun factory_test: JavaString in "Java" `{ return Intent.ACTION_FACTORY_TEST; `}
 461
 462         # Standard Broadcast Actions
 463         fun time_tick: JavaString in "Java" `{ return Intent.ACTION_TIME_TICK; `}
 464         fun time_changed: JavaString in "Java" `{ return Intent.ACTION_TIME_CHANGED; `}
 465         fun timezone_changed: JavaString in "Java" `{ return Intent.ACTION_TIMEZONE_CHANGED; `}
 466         fun boot_completed: JavaString in "Java" `{ return Intent.ACTION_BOOT_COMPLETED; `}
 467         fun package_added: JavaString in "Java" `{ return Intent.ACTION_PACKAGE_ADDED; `}
 468         fun package_changed: JavaString in "Java" `{ return Intent.ACTION_PACKAGE_CHANGED; `}
 469         fun package_removed: JavaString in "Java" `{ return Intent.ACTION_PACKAGE_REMOVED; `}
 470         fun package_restarted: JavaString in "Java" `{ return Intent.ACTION_PACKAGE_RESTARTED; `}
 471         fun package_data_cleared: JavaString in "Java" `{
 472                 return Intent.ACTION_PACKAGE_DATA_CLEARED;
 473         `}
 474         fun uid_removed: JavaString in "Java" `{ return Intent.ACTION_UID_REMOVED; `}
 475         fun battery_changed: JavaString in "Java" `{ return Intent.ACTION_BATTERY_CHANGED; `}
 476         fun power_connected: JavaString in "Java" `{ return Intent.ACTION_POWER_CONNECTED; `}
 477         fun power_disconnected: JavaString in "Java" `{ return Intent.ACTION_POWER_DISCONNECTED; `}
 478         fun shutdown: JavaString in "Java" `{ return Intent.ACTION_SHUTDOWN; `}
 479 end
 480
 481 # A category gives extra information about the action to execute
 482 # Designed to be used with the `intent_category` function
 483 # Example : `intent_category.home`
 484 #
 485 # For further details on categories, refer to Android Intent documentation
 486 class Category
 487         fun alternative: JavaString in "Java" `{ return Intent.CATEGORY_ALTERNATIVE; `}
 488         fun car_dock: JavaString in "Java" `{ return Intent.CATEGORY_CAR_DOCK; `}
 489         fun car_mode: JavaString in "Java" `{ return Intent.CATEGORY_CAR_MODE; `}
 490         fun default: JavaString in "Java" `{ return Intent.CATEGORY_DEFAULT; `}
 491         fun desk_dock: JavaString in "Java" `{ return Intent.CATEGORY_DESK_DOCK; `}
 492         fun development_preference: JavaString in "Java" `{
 493                 return Intent.CATEGORY_DEVELOPMENT_PREFERENCE;
 494         `}
 495         fun embed: JavaString in "Java" `{ return Intent.CATEGORY_EMBED; `}
 496         fun framework_instrumentation_test: JavaString in "Java" `{
 497                 return Intent.CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST;
 498         `}
 499         fun home: JavaString in "Java" `{ return Intent.CATEGORY_HOME; `}
 500         fun info: JavaString in "Java" `{ return Intent.CATEGORY_INFO; `}
 501         fun launcher: JavaString in "Java" `{ return Intent.CATEGORY_LAUNCHER; `}
 502         fun monkey: JavaString in "Java" `{ return Intent.CATEGORY_MONKEY; `}
 503         fun openable: JavaString in "Java" `{ return Intent.CATEGORY_OPENABLE; `}
 504         fun preference: JavaString in "Java" `{ return Intent.CATEGORY_PREFERENCE; `}
 505         fun sample_code: JavaString in "Java" `{ return Intent.CATEGORY_SAMPLE_CODE; `}
 506         fun selected_alternative: JavaString in "Java" `{
 507                 return Intent.CATEGORY_SELECTED_ALTERNATIVE;
 508         `}
 509         fun tab: JavaString in "Java" `{ return Intent.CATEGORY_TAB; `}
 510         fun test: JavaString in "Java" `{ return Intent.CATEGORY_TEST; `}
 511         fun unit_test: JavaString in "Java" `{ return Intent.CATEGORY_UNIT_TEST; `}
 512 end
 513
 514 # Used to add any additional information.
 515 #
 516 # For further details on extras, refer to Android Intent documentation
 517 class Extra
 518         fun alarm_count: JavaString in "Java" `{ return Intent.EXTRA_ALARM_COUNT; `}
 519         fun bcc: JavaString in "Java" `{ return Intent.EXTRA_BCC; `}
 520         fun cc: JavaString in "Java" `{ return Intent.EXTRA_CC; `}
 521         fun changed_component_name: JavaString in "Java" `{
 522                 return Intent.EXTRA_CHANGED_COMPONENT_NAME;
 523         `}
 524         fun changed_component_name_list: JavaString in "Java" `{
 525                 return Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST;
 526         `}
 527         fun changed_package_list: JavaString in "Java" `{
 528                 return Intent.EXTRA_CHANGED_PACKAGE_LIST;
 529         `}
 530         fun changed_uid_list: JavaString in "Java" `{ return Intent.EXTRA_CHANGED_UID_LIST; `}
 531         fun data_removed: JavaString in "Java" `{ return Intent.EXTRA_DATA_REMOVED; `}
 532         fun dock_state: JavaString in "Java" `{ return Intent.EXTRA_DOCK_STATE; `}
 533         fun dock_state_car: Int in "Java" `{ return Intent.EXTRA_DOCK_STATE_CAR; `}
 534         fun dock_state_desk: Int in "Java" `{ return Intent.EXTRA_DOCK_STATE_DESK; `}
 535         fun dock_state_undocked: Int in "Java" `{ return Intent.EXTRA_DOCK_STATE_UNDOCKED; `}
 536         fun dont_kill_app: JavaString in "Java" `{ return Intent.EXTRA_DONT_KILL_APP; `}
 537         fun email: JavaString in "Java" `{ return Intent.EXTRA_EMAIL; `}
 538         fun initial_intents: JavaString in "Java" `{ return Intent.EXTRA_INITIAL_INTENTS; `}
 539         fun intent: JavaString in "Java" `{ return Intent.EXTRA_INTENT; `}
 540         fun key_event: JavaString in "Java" `{ return Intent.EXTRA_KEY_EVENT; `}
 541         fun phone_number: JavaString in "Java" `{ return Intent.EXTRA_PHONE_NUMBER; `}
 542         fun remote_intent_token: JavaString in "Java" `{
 543                 return Intent.EXTRA_REMOTE_INTENT_TOKEN;
 544         `}
 545         fun replacing: JavaString in "Java" `{ return Intent.EXTRA_REPLACING; `}
 546         fun shortcut_icon: JavaString in "Java" `{ return Intent.EXTRA_SHORTCUT_ICON; `}
 547         fun shortcut_icon_resource: JavaString in "Java" `{
 548                 return Intent.EXTRA_SHORTCUT_ICON_RESOURCE;
 549         `}
 550         fun shortcut_intent: JavaString in "Java" `{ return Intent.EXTRA_SHORTCUT_INTENT; `}
 551         fun stream: JavaString in "Java" `{ return Intent.EXTRA_STREAM; `}
 552         fun subject: JavaString in "Java" `{ return Intent.EXTRA_SUBJECT; `}
 553         fun template: JavaString in "Java" `{ return Intent.EXTRA_TEMPLATE; `}
 554         fun text: JavaString in "Java" `{ return Intent.EXTRA_TEXT; `}
 555         fun title: JavaString in "Java" `{ return Intent.EXTRA_TITLE; `}
 556         fun uid: JavaString in "Java" `{ return Intent.EXTRA_UID; `}
 557 end
 558
 559 # A Flag controls how to handle the Intent
 560 # Designed to be used with the `intent_flag` function
 561 # Example : `intent_flag.activity_brought_to_front`
 562 #
 563 # For further details on flags, refer to Android Intent documentation
 564 class Flag
 565         fun activity_brought_to_front: Int in "Java" `{
 566                 return Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT;
 567         `}
 568         fun activity_clear_top: Int in "Java" `{
 569                 return Intent.FLAG_ACTIVITY_CLEAR_TOP;
 570         `}
 571         fun activity_clear_when_task_reset: Int in "Java" `{
 572                 return Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET;
 573         `}
 574         fun activity_exclude_from_recents: Int in "Java" `{
 575                 return Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
 576         `}
 577         fun activity_forward_result: Int in "Java" `{
 578                 return Intent.FLAG_ACTIVITY_FORWARD_RESULT;
 579         `}
 580         fun activity_launched_from_history: Int in "Java" `{
 581                 return Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY;
 582         `}
 583         fun activity_multiple_task: Int in "Java" `{
 584                 return Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
 585         `}
 586         fun activity_new_task: Int in "Java" `{
 587                 return Intent.FLAG_ACTIVITY_NEW_TASK;
 588         `}
 589         fun activity_no_animation: Int in "Java" `{
 590                 return Intent.FLAG_ACTIVITY_NO_ANIMATION;
 591         `}
 592         fun activity_no_history: Int in "Java" `{
 593                 return Intent.FLAG_ACTIVITY_NO_HISTORY;
 594         `}
 595         fun activity_no_user_action: Int in "Java" `{
 596                 return Intent.FLAG_ACTIVITY_NO_USER_ACTION;
 597         `}
 598         fun activity_previous_is_top: Int in "Java" `{
 599                 return Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP;
 600         `}
 601         fun activity_reorder_to_front: Int in "Java" `{
 602                 return Intent.FLAG_ACTIVITY_REORDER_TO_FRONT;
 603         `}
 604         fun activity_reset_task_if_needed: Int in "Java" `{
 605                 return Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED;
 606         `}
 607         fun activity_single_top: Int in "Java" `{
 608                 return Intent.FLAG_ACTIVITY_SINGLE_TOP;
 609         `}
 610         fun debug_log_resolution: Int in "Java" `{
 611                 return Intent.FLAG_DEBUG_LOG_RESOLUTION;
 612         `}
 613         fun from_background: Int in "Java" `{
 614                 return Intent.FLAG_FROM_BACKGROUND;
 615         `}
 616         fun grant_read_uri_permission: Int in "Java" `{
 617                 return Intent.FLAG_GRANT_READ_URI_PERMISSION;
 618         `}
 619         fun grant_write_uri_permission: Int in "Java" `{
 620                 return Intent.FLAG_GRANT_WRITE_URI_PERMISSION;
 621         `}
 622         fun receiver_registered_only: Int in "Java" `{
 623                 return Intent.FLAG_RECEIVER_REGISTERED_ONLY;
 624         `}
 625         fun receiver_replace_pending: Int in "Java" `{
 626                 return Intent.FLAG_RECEIVER_REPLACE_PENDING;
 627         `}
 628 end
 629
 630 # Services allowing to launch an activity and start/stop services
 631 class Intent
 632         protected var intent: NativeIntent = (new NativeIntent).new_global_ref is lazy
 633
 634         # The general action to be performed
 635         #
 636         # ~~~nitish
 637         # # TODO better example
 638         # intent.action = intent_action.view.to_s
 639         # ~~~
 640         fun action=(action: String)
 641         do
 642                 sys.jni_env.push_local_frame(1)
 643                 intent.action = action.to_java_string
 644                 sys.jni_env.pop_local_frame
 645         end
 646
 647         # Returns the action to be performed or `null` if none
 648         fun action: nullable String do
 649                 var result = intent.action.to_s
 650                 if result == "" then return null
 651                 return result
 652         end
 653
 654         # Add category to the intent
 655         # Only activities providing all of the requested categories will be used
 656         #
 657         # ~~~nitish
 658         # # TODO better example
 659         # intent.add_category(intent_category.home.to_s)
 660         # ~~~
 661         # Returns `self` allowing fluent programming
 662         fun add_category(category: String): Intent
 663         do
 664                 sys.jni_env.push_local_frame(1)
 665                 intent.add_category(category.to_java_string)
 666                 sys.jni_env.pop_local_frame
 667                 return self
 668         end
 669
 670         # Returns all the intent categories or `null` if none
 671         fun categories: nullable HashSet[String]
 672         do
 673                 var string_set = intent.categories
 674                 if string_set.is_empty then return null
 675
 676                 return string_set
 677         end
 678
 679         # Sets the data uri the intent is working on
 680         # Automatically clears the type field set using `mime_type=` method as it
 681         # uses the data uri to determine the MIME type
 682         # Note: The Uri string has to comply with RFC 2396
 683         fun data=(data_uri: String)
 684         do
 685                 sys.jni_env.push_local_frame(1)
 686                 intent.data = data_uri.to_java_string
 687                 sys.jni_env.pop_local_frame
 688         end
 689
 690         # Returns the data Uri the data is operating on or `null` if none
 691         fun data: nullable String
 692         do
 693                 var result = intent.data.to_s
 694                 if result == "" then return null
 695                 return result
 696         end
 697
 698         # Sets an explicit MIME data type to be handled by the intent, for example
 699         # the return data type
 700         # Automatically clears the data type field set using `data=` method
 701         fun mime_type=(mime_type: String)
 702         do
 703                 sys.jni_env.push_local_frame(1)
 704                 intent.mime_type = mime_type.to_java_string
 705                 sys.jni_env.pop_local_frame
 706         end
 707
 708         # Add a flag to be used by the intent
 709         #
 710         # ~~~nitish
 711         # # TODO better example
 712         # intent.add_flags(intent_flag.activity_new_task)
 713         # ~~~
 714         # Returns `self` allowing fluent programming
 715         fun add_flags(flags: Int): Intent
 716         do
 717                 intent.add_flags(flags)
 718                 return self
 719         end
 720
 721         # Returns an `Int` representing all the intent flags
 722         fun flags: Int do return intent.flags
 723
 724         # Returns the package name the intent resolution is limited to
 725         # Returns `null` if not defined
 726         fun package_name: nullable String do
 727                 var result = intent.get_package.to_s
 728                 if result == "" then return null
 729                 return result
 730         end
 731
 732         # Returns the set MIME and `null` if none
 733         fun type_name: nullable String do
 734                 var result = intent.get_type.to_s
 735                 if result == "" then return null
 736                 return result
 737         end
 738
 739         # Returns `true` if the intent contains the given category
 740         fun has_category(category: String): Bool
 741         do
 742                 sys.jni_env.push_local_frame(1)
 743                 var return_value = intent.has_category(category.to_java_string)
 744                 sys.jni_env.pop_local_frame
 745                 return return_value
 746         end
 747
 748         # Returns `true` if the intent contains the given extra
 749         fun has_extra(extra: String): Bool
 750         do
 751                 sys.jni_env.push_local_frame(1)
 752                 var return_value = intent.has_extra(extra.to_java_string)
 753                 sys.jni_env.pop_local_frame
 754                 return return_value
 755         end
 756
 757         # Removes the given category
 758         # Returns `self` allowing fluent programming
 759         fun remove_category(category: String): Intent
 760         do
 761                 sys.jni_env.push_local_frame(1)
 762                 intent.remove_category(category.to_java_string)
 763                 sys.jni_env.pop_local_frame
 764                 return self
 765         end
 766
 767         # Removes the given extra
 768         # Returns `self` allowing fluent programming
 769         fun remove_extra(name: String): Intent
 770         do
 771                 sys.jni_env.push_local_frame(1)
 772                 intent.remove_extra(name.to_java_string)
 773                 sys.jni_env.pop_local_frame
 774                 return self
 775         end
 776
 777         # Retrieves the `Array[Bool]` extra stored as Java `boolean[]` with the
 778         # corresponding name
 779         fun extra_bool_array(name: String): Array[Bool]
 780         do
 781                 sys.jni_env.push_local_frame(1)
 782                 var nit_array = intent.boolean_array_extra(name.to_java_string)
 783                 sys.jni_env.pop_local_frame
 784                 return nit_array
 785         end
 786
 787         # Retrieves the `Bool` extra stored with the corresponding name
 788         fun extra_bool(name: String, def_value: Bool): Bool
 789         do
 790                 sys.jni_env.push_local_frame(1)
 791                 var nit_bool = intent.boolean_extra(name.to_java_string, def_value)
 792                 sys.jni_env.pop_local_frame
 793                 return nit_bool
 794         end
 795
 796         # Retrieves the `Array[Int]` extra stored as Java `byte[]` with the
 797         # corresponding name
 798         fun extra_byte_array(name: String): Array[Int]
 799         do
 800                 sys.jni_env.push_local_frame(1)
 801                 var nit_array = intent.byte_array_extra(name.to_java_string)
 802                 sys.jni_env.pop_local_frame
 803                 return nit_array
 804         end
 805
 806         # Retrieves the `Int` extra stored as Java `byte` with the corresponding name
 807         fun extra_byte(name: String, def_value: Int): Int
 808         do
 809                 sys.jni_env.push_local_frame(1)
 810                 var nit_int = intent.byte_extra(name.to_java_string, def_value)
 811                 sys.jni_env.pop_local_frame
 812                 return nit_int
 813         end
 814
 815         # Retrieves the `Array[Char]` extra stored as Java `char[]` with the
 816         # corresponding name
 817         # FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
 818         fun extra_char_array(name: String): Array[Char]
 819         do
 820                 sys.jni_env.push_local_frame(1)
 821                 var nit_array = intent.char_array_extra(name.to_java_string)
 822                 sys.jni_env.pop_local_frame
 823                 return nit_array
 824         end
 825
 826         # Retrieves the `Char` extra stored as Java `char` with the
 827         # corresponding name
 828         # FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
 829         fun extra_char(name: String, def_value: Char): Char
 830         do
 831                 sys.jni_env.push_local_frame(1)
 832                 var nit_char = intent.char_extra(name.to_java_string, def_value)
 833                 sys.jni_env.pop_local_frame
 834                 return nit_char
 835         end
 836
 837         # Retrieves the `String` extra stored as Java `CharSequence` with the
 838         # corresponding name
 839         fun extra_char_sequence(name: String, def_value: String ): String
 840         do
 841                 sys.jni_env.push_local_frame(1)
 842                 var nit_charseq =
 843                         intent.char_sequence_extra(name.to_java_string).to_s
 844                 sys.jni_env.pop_local_frame
 845                 return nit_charseq
 846         end
 847
 848         # Retrieves the `Array[String]` extra stored as Java `ArrayList<CharSequence>`
 849         # with the corresponding name
 850         fun extra_char_sequence_array_list_extra(name: String): Array[String]
 851         do
 852                 sys.jni_env.push_local_frame(1)
 853                 var string_array = intent.char_sequence_array_list_extra(name.to_java_string)
 854                 sys.jni_env.pop_local_frame
 855                 return string_array
 856         end
 857
 858         # Retrieves the `Array[String]` extra stored as Java `CharSequence[]`
 859         # with the corresponding name
 860         fun extra_char_sequence_array(name: String): Array[String]
 861         do
 862                 sys.jni_env.push_local_frame(1)
 863                 var string_array = intent.char_sequence_array_list_extra(name.to_java_string)
 864                 sys.jni_env.pop_local_frame
 865                 return string_array
 866         end
 867
 868         # Retrieves the `Array[Float]` extra stored as Java `double[]` with the
 869         # corresponding name
 870         fun extra_double_array(name: String): Array[Float]
 871         do
 872                 sys.jni_env.push_local_frame(1)
 873                 var nit_array = intent.double_array_extra(name.to_java_string)
 874                 sys.jni_env.pop_local_frame
 875                 return nit_array
 876         end
 877
 878         # Retrieves the `Float` extra stored as Java `double` with the corresponding
 879         # name
 880         fun extra_double(name: String, def_value: Float): Float
 881         do
 882                 sys.jni_env.push_local_frame(1)
 883                 var nit_float = intent.double_extra(name.to_java_string, def_value)
 884                 sys.jni_env.pop_local_frame
 885                 return nit_float
 886         end
 887
 888         # Retrieves the `Array[Float]` extra stored as Java `float[]` with the
 889         # corresponding name
 890         fun extra_float_array(name: String): Array[Float]
 891         do
 892                 sys.jni_env.push_local_frame(1)
 893                 var nit_array = intent.float_array_extra(name.to_java_string)
 894                 sys.jni_env.pop_local_frame
 895                 return nit_array
 896         end
 897
 898         # Retrieves the `Float` extra stored as Java `float` with the corresponding
 899         # name
 900         fun extra_float(name: String, def_value: Float): Float
 901         do
 902                 sys.jni_env.push_local_frame(1)
 903                 var nit_float = intent.float_extra(name.to_java_string, def_value)
 904                 sys.jni_env.pop_local_frame
 905                 return nit_float
 906         end
 907
 908         # Retrieves the `Array[Int]` extra stored as Java `int[]` with the
 909         # corresponding name
 910         fun extra_int_array(name: String): Array[Int]
 911         do
 912                 sys.jni_env.push_local_frame(1)
 913                 var nit_array = intent.int_array_extra(name.to_java_string)
 914                 sys.jni_env.pop_local_frame
 915                 return nit_array
 916         end
 917
 918         # Retrieves the `Int` extra stored as Java `int` with the corresponding
 919         # name
 920         fun extra_int(name: String, def_value: Int): Int
 921         do
 922                 sys.jni_env.push_local_frame(1)
 923                 var nit_int = intent.int_extra(name.to_java_string, def_value)
 924                 sys.jni_env.pop_local_frame
 925                 return nit_int
 926         end
 927
 928         # Retrieves the `Array[Int]` extra stored as Java `long[]` with the
 929         # corresponding name
 930         fun extra_long_array(name: String): Array[Int]
 931         do
 932                 sys.jni_env.push_local_frame(1)
 933                 var nit_array = intent.long_array_extra(name.to_java_string)
 934                 sys.jni_env.pop_local_frame
 935                 return nit_array
 936         end
 937
 938         # Retrieves the `Int` extra stored as Java `long` with the corresponding
 939         # name
 940         fun extra_long(name: String, def_value: Int): Int
 941         do
 942                 sys.jni_env.push_local_frame(1)
 943                 var nit_int = intent.long_extra(name.to_java_string, def_value)
 944                 sys.jni_env.pop_local_frame
 945                 return nit_int
 946         end
 947
 948         # Retrieves the `Array[Int]` extra stored as Java `short[]` with the
 949         # corresponding name
 950         fun extra_short_array(name: String): Array[Int]
 951         do
 952                 sys.jni_env.push_local_frame(1)
 953                 var nit_array = intent.short_array_extra(name.to_java_string)
 954                 sys.jni_env.pop_local_frame
 955                 return nit_array
 956         end
 957
 958         # Retrieves the `Int` extra stored as Java `short` with the corresponding
 959         # name
 960         fun extra_short(name: String, def_value: Int): Int
 961         do
 962                 sys.jni_env.push_local_frame(1)
 963                 var nit_int = intent.short_extra(name.to_java_string, def_value)
 964                 sys.jni_env.pop_local_frame
 965                 return nit_int
 966         end
 967
 968         # Retrieves the `Array[String]` extra stored as Java `String[]` with the
 969         # corresponding name
 970         fun extra_string_array(name: String): Array[String]
 971         do
 972                 sys.jni_env.push_local_frame(1)
 973                 var string_array = intent.string_array_extra(name.to_java_string)
 974                 sys.jni_env.pop_local_frame
 975                 return string_array
 976         end
 977
 978         # Retrieves the `Array[String]` extra stored as Java `ArrayList<String>`
 979         # with the corresponding name
 980         fun extra_string_array_list(name: String): Array[String]
 981         do
 982                 sys.jni_env.push_local_frame(1)
 983                 var string_array = intent.string_array_list_extra(name.to_java_string)
 984                 sys.jni_env.pop_local_frame
 985                 return string_array
 986         end
 987
 988         # Retrieves the `String` extra stored as Java `String` with the corresponding
 989         # name
 990         fun extra_string(name: String): String
 991         do
 992                 sys.jni_env.push_local_frame(1)
 993                 var nit_java_string = intent.string_extra(name.to_java_string).to_s
 994                 sys.jni_env.pop_local_frame
 995                 return nit_java_string
 996         end
 997
 998         # Adds extra data corresponding to `double` java type
 999         # Returns `self` allowing fluent programming
1000         fun add_extra_double(name: String, value: Float): Intent
1001         do
1002                 sys.jni_env.push_local_frame(1)
1003                 intent.add_extra_double(name.to_java_string, value)
1004                 sys.jni_env.pop_local_frame
1005                 return self
1006         end
1007
1008         # Adds extra data corresponding to `double[]` java type
1009         # Returns `self` allowing fluent programming
1010         fun add_extra_array_of_double(name: String, value: Array[Float]): Intent
1011         do
1012                 sys.jni_env.push_local_frame(1)
1013                 intent.add_extra_array_of_double(name.to_java_string, value)
1014                 sys.jni_env.pop_local_frame
1015                 return self
1016         end
1017
1018         # Adds extra data corresponding to `char` java type
1019         # Returns `self` allowing fluent programming
1020         # FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
1021         fun add_extra_char(name: String, value: Char): Intent
1022         do
1023                 sys.jni_env.push_local_frame(1)
1024                 intent.add_extra_char(name.to_java_string, value)
1025                 sys.jni_env.pop_local_frame
1026                 return self
1027         end
1028
1029         # Adds extra data corresponding to `char[]` java type
1030         # Returns `self` allowing fluent programming
1031         # FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
1032         fun add_extra_array_of_char(name: String, value: Array[Char]): Intent
1033         do
1034                 sys.jni_env.push_local_frame(1)
1035                 intent.add_extra_array_of_char(name.to_java_string, value)
1036                 sys.jni_env.pop_local_frame
1037                 return self
1038         end
1039
1040         # Adds extra data corresponding to `CharSequence` java type
1041         # Returns `self` allowing fluent programming
1042         fun add_extra_char_sequence(name: String, value: String): Intent
1043         do
1044                 sys.jni_env.push_local_frame(2)
1045                 intent.add_extra_char_sequence(name.to_java_string, value.to_java_string)
1046                 sys.jni_env.pop_local_frame
1047                 return self
1048         end
1049
1050         # Adds extra data corresponding to `CharSequence[]` java type
1051         # Returns `self` allowing fluent programming
1052         fun add_extra_array_of_char_sequence(name: String, value: Array[String]): Intent
1053         do
1054                 sys.jni_env.push_local_frame(value.length + 1)
1055                 var java_string_array = new Array[JavaString]
1056                 for element in value do
1057                         java_string_array.push(element.to_java_string)
1058                 end
1059                 intent.add_extra_array_of_char_sequence(name.to_java_string, java_string_array)
1060                 sys.jni_env.pop_local_frame
1061                 return self
1062         end
1063
1064         # Adds extra data corresponding to `bundle` java type
1065         # Returns `self` allowing fluent programming
1066         fun add_extra_bundle(name: String, value: NativeBundle): Intent
1067         do
1068                 sys.jni_env.push_local_frame(1)
1069                 intent.add_extra_bundle(name.to_java_string, value)
1070                 sys.jni_env.pop_local_frame
1071                 return self
1072         end
1073
1074         # Adds extra data corresponding to `int` java type
1075         # Returns `self` allowing fluent programming
1076         # *Be aware of possible integer overflow as Nit `Int` corresponds to*
1077         # *java `long` and the expected value is a java `int`*
1078         # Consider using add_extra_long instead
1079         fun add_extra_int(name: String, value: Int): Intent
1080         do
1081                 sys.jni_env.push_local_frame(1)
1082                 intent.add_extra_int(name.to_java_string, value)
1083                 sys.jni_env.pop_local_frame
1084                 return self
1085         end
1086
1087         # Adds extra data corresponding to `int[]` java type
1088         # Returns `self` allowing fluent programming
1089         # *Be aware of possible integer overflow as Nit `Int` corresponds to*
1090         # *java `long` and the expected value is a java `int[]`*
1091         # Consider using add_extra_array_of_long instead
1092         fun add_extra_array_of_int(name: String, value: Array[Int]): Intent
1093         do
1094                 sys.jni_env.push_local_frame(1)
1095                 intent.add_extra_array_of_int(name.to_java_string, value)
1096                 sys.jni_env.pop_local_frame
1097                 return self
1098         end
1099
1100         # Adds extra data corresponding to `ArrayList<Integer>` java type
1101         # Returns `self` allowing fluent programming
1102         # *Be aware of possible integer overflow as Nit `Int` corresponds to*
1103         # *java `long` and the expected value is a java `ArrayList<Integer>`*
1104         # Consider using add_extra_array_of_long instead
1105         fun add_extra_array_list_of_int(name: String, value: Array[Int]): Intent
1106         do
1107                 sys.jni_env.push_local_frame(1)
1108                 intent.add_extra_array_list_of_int(name.to_java_string, value)
1109                 sys.jni_env.pop_local_frame
1110                 return self
1111         end
1112
1113         # Adds extra data corresponding to `byte` java type
1114         # Returns `self` allowing fluent programming
1115         # *Be aware of possible integer overflow as Nit `Int` corresponds to*
1116         # *java `long` and the expected value is a java `byte`*
1117         # Consider using add_extra_array_of_long instead
1118         fun add_extra_byte(name: String, value: Int): Intent
1119         do
1120                 sys.jni_env.push_local_frame(1)
1121                 intent.add_extra_byte(name.to_java_string, value)
1122                 sys.jni_env.pop_local_frame
1123                 return self
1124         end
1125
1126         # Adds extra data corresponding to `byte[]` java type
1127         # Returns `self` allowing fluent programming
1128         # *Be aware of possible integer overflow as Nit `Int` corresponds to*
1129         # *java `long` and the expected value is a java `byte[]`*
1130         # Consider using add_extra_array_of_long instead
1131         fun add_extra_array_of_byte(name: String, value: Int): Intent
1132         do
1133                 sys.jni_env.push_local_frame(1)
1134                 intent.add_extra_array_of_byte(name.to_java_string, value)
1135                 sys.jni_env.pop_local_frame
1136                 return self
1137         end
1138
1139         # Adds extra data corresponding to `long` java type
1140         # Returns `self` allowing fluent programming
1141         fun add_extra_long(name: String, value: Int): Intent
1142         do
1143                 sys.jni_env.push_local_frame(1)
1144                 intent.add_extra_long(name.to_java_string, value)
1145                 sys.jni_env.pop_local_frame
1146                 return self
1147         end
1148
1149         # Adds extra data corresponding to `long[]` java type
1150         # Returns `self` allowing fluent programming
1151         fun add_extra_array_of_long(name: String, value: Array[Int]): Intent
1152         do
1153                 sys.jni_env.push_local_frame(1)
1154                 intent.add_extra_array_of_long(name.to_java_string, value)
1155                 sys.jni_env.pop_local_frame
1156                 return self
1157         end
1158
1159         # Adds extra data corresponding to `float` java type
1160         # Returns `self` allowing fluent programming
1161         # *Be aware of possible loss of precision as Nit `Float` corresponds to*
1162         # *java `double` and the expected value is a java `float`*
1163         # Consider using add_extra_double
1164         fun add_extra_float(name: String, value: Float): Intent
1165         do
1166                 sys.jni_env.push_local_frame(1)
1167                 intent.add_extra_float(name.to_java_string, value)
1168                 sys.jni_env.pop_local_frame
1169                 return self
1170         end
1171
1172         # Adds extra data corresponding to `float[]` java type
1173         # Returns `self` allowing fluent programming
1174         # *Be aware of possible loss of precision as Nit `Float` corresponds to*
1175         # *java `double` and the expected value is a java `float[]`*
1176         # Consider using add_extra_array_of_double
1177         fun add_extra_array_of_float(name: String, value: Array[Float]): Intent
1178         do
1179                 sys.jni_env.push_local_frame(1)
1180                 intent.add_extra_array_of_float(name.to_java_string, value)
1181                 sys.jni_env.pop_local_frame
1182                 return self
1183         end
1184
1185         # Adds extra data corresponding to `String` java type
1186         # Returns `self` allowing fluent programming
1187         fun add_extra_string(name: String, value: String): Intent
1188         do
1189                 sys.jni_env.push_local_frame(2)
1190                 intent.add_extra_string(name.to_java_string, value.to_java_string)
1191                 sys.jni_env.pop_local_frame
1192                 return self
1193         end
1194
1195         # Adds extra data corresponding to `String[]` java type
1196         # Returns `self` allowing fluent programming
1197         fun add_extra_array_of_string(name: String, value: Array[String]): Intent
1198         do
1199                 sys.jni_env.push_local_frame(value.length + 1)
1200                 var java_string_array = new Array[JavaString]
1201                 for element in value do
1202                         java_string_array.push(element.to_java_string)
1203                 end
1204                 intent.add_extra_array_of_string(name.to_java_string, java_string_array)
1205                 sys.jni_env.pop_local_frame
1206                 return self
1207         end
1208
1209         # Adds extra data corresponding to `ArrayList<String>` java type
1210         # Returns `self` allowing fluent programming
1211         fun add_extra_array_list_of_string(name: String, value: Array[String]): Intent
1212         do
1213                 sys.jni_env.push_local_frame(value.length + 1)
1214                 var java_string_array = new Array[JavaString]
1215                 for element in value do
1216                         java_string_array.push(element.to_java_string)
1217                 end
1218
1219                 intent.add_extra_array_list_of_string(name.to_java_string, java_string_array)
1220                 sys.jni_env.pop_local_frame
1221                 return self
1222         end
1223
1224         # Adds extra data corresponding to `boolean` java type
1225         # Returns `self` allowing fluent programming
1226         fun add_extra_bool(name: String, value: Bool): Intent
1227         do
1228                 sys.jni_env.push_local_frame(1)
1229                 intent.add_extra_bool(name.to_java_string, value)
1230                 sys.jni_env.pop_local_frame
1231                 return self
1232         end
1233
1234         # Adds extra data corresponding to `boolean[]` java type
1235         # Returns `self` allowing fluent programming
1236         fun add_extra_array_of_bool(name: String, value: Array[Bool]): Intent
1237         do
1238                 sys.jni_env.push_local_frame(1)
1239                 intent.add_extra_array_of_bool(name.to_java_string, value)
1240                 sys.jni_env.pop_local_frame
1241                 return self
1242         end
1243
1244         # Adds extra data corresponding to `short` java type
1245         # Returns `self` allowing fluent programming
1246         # *Be aware of possible integer overflow as Nit `Int` corresponds to*
1247         # *java `long` and the expected value is a java `short`*
1248         # Consider using add_extra_long instead
1249         fun add_extra_short(name: String, value: Int): Intent
1250         do
1251                 sys.jni_env.push_local_frame(1)
1252                 intent.add_extra_short(name.to_java_string, value)
1253                 sys.jni_env.pop_local_frame
1254                 return self
1255         end
1256
1257         # Adds extra data corresponding to `short[]` java type
1258         # Returns `self` allowing fluent programming
1259         # *Be aware of possible integer overflow as Nit `Int` corresponds to*
1260         # *java `long` and the expected value is a java `short[]`*
1261         # Consider using add_extra_array_of_long instead
1262         fun add_extra_array_of_short(name: String, value: Array[Int]): Intent
1263         do
1264                 sys.jni_env.push_local_frame(1)
1265                 intent.add_extra_array_of_short(name.to_java_string, value)
1266                 sys.jni_env.pop_local_frame
1267                 return self
1268         end
1269
1270         # Store `value` as a serialized Json string
1271         # java method according to value type
1272         # Returns `self` allowing fluent programming
1273         fun []=(name: String, value: nullable Serializable): Intent
1274         do
1275                 var serialized_string = new StringWriter
1276                 var serializer = new JsonSerializer(serialized_string)
1277                 serializer.serialize(value)
1278
1279                 add_extra_string(name, serialized_string.to_s)
1280                 return self
1281         end
1282
1283         # Retrieve an `Object` stored via `[]=` function
1284         fun [](name: String): nullable Object
1285         do
1286                 var serialized_string = self.extra_string(name)
1287                 if serialized_string == "" then return null
1288
1289                 var deserializer = new JsonDeserializer(serialized_string)
1290                 return deserializer.deserialize
1291         end
1292
1293         # Specify the class to be launched by the intent
1294         fun set_class_name(package_name: String, class_name: String): Intent
1295         do
1296                 sys.jni_env.push_local_frame(2)
1297                 intent.set_class_name(package_name.to_java_string, class_name.to_java_string)
1298                 sys.jni_env.pop_local_frame
1299                 return self
1300         end
1301
1302         # Deletes intent global reference
1303         fun destroy do self.intent.delete_global_ref
1304
1305         # Returns a human readable representation of the intent
1306         redef fun to_s do return intent.to_native_s.to_s
1307 end
1308
1309 redef extern class NativeContext
1310         private fun start_activity(intent: NativeIntent) in "Java" `{ self.startActivity(intent); `}
1311         private fun start_service(intent: NativeIntent) in "Java" `{ self.startService(intent); `}
1312         private fun stop_service(intent: NativeIntent) in "Java" `{ self.stopService(intent); `}
1313 end
1314
1315 # Allows user to get values with enum-like syntax : `intent_action.main`
1316 fun intent_action: Action do return once new Action
1317 # Allows user to get values with enum-like syntax : `intent_category.home`
1318 fun intent_category: Category do return once new Category
1319 # Allows user to get values with enum-like syntax : `intent_flag.activity_brought_to_front`
1320 fun intent_flag: Flag do return once new Flag
1321
1322 private class StringCopyArray
1323         var collection = new Array[String]
1324         fun add(element: JavaString) do collection.add element.to_s
1325 end
1326
1327 private class StringCopyHashSet
1328         var collection = new HashSet[String]
1329         fun add(element: JavaString) do collection.add element.to_s
1330 end
1331
1332 redef class App
1333
1334         # Execute the intent and launch the appropriate application
1335         fun start_activity(intent: Intent) do native_context.start_activity(intent.intent)
1336
1337         # Start a service that will be running until the `stop_service` call
1338         fun start_service(intent: Intent) do native_context.start_service(intent.intent)
1339
1340         # Stop service
1341         fun stop_service(intent: Intent) do native_context.stop_service(intent.intent)
1342 end