-->

Menú principal

martes, 14 de marzo de 2017

Desarrollo de aplicaciones para móviles Android con RFO-BASIC

 Página principal de RFO Basic

1.- ¿Qué es RFO Basic? ¿Por qué usarlo?


RFO Basic es una herramienta de desarrollo única y productiva que se puede utilizar para crear aplicaciones potentes para teléfonos y dispositivos Android. No hay absolutamente ninguna manera más fácil de programar aplicaciones para Android.

RFO Basic se ejecuta completamente en su dispositivo Android. Es una solución de programación minúscula, autocontenida, en el dispositivo, que no requiere ningún software instalado en una computadora de escritorio. Puede crear aplicaciones de RFO Basic en su PC de escritorio, y si instala el IDE de Eclipse y la API de Android, podrá producir archivos completos APK de Android ("aplicaciones", "programas") que se pueden distribuir en la Tienda de aplicaciones de Android.

Para aquellos que quieren la solución de despliegue más simple posible, hay un pequeño programa gratuito para Windows que crea APKs automáticamente para usted. No se requiere ningún conocimiento adicional del entorno de Android.

RFO Basic es potente. Proporciona acceso a hardware, sensores, sonido, gráficos, multitouch, sistema de archivos, SQLite, sockets de red, FTP, HTTP, bluetooth, GUI de HTML, cifrado, SMS, teléfono, correo electrónico, texto a voz, reconocimiento de voz, Matemáticas, funciones de cadenas, funciones de lista, etc. A diferencia de otros sabores de BASIC que se limitan a introducir conceptos fundamentales de programación, RFO Basic es un lenguaje rico, moderno y lleno de características.

Aunque es fácil de usar, no es un juguete, sino una herramienta práctica para crear software Android útil. RFO Basic es 100% libre y de código abierto.

RFO Basic es apoyado por una comunidad amigable y bien informada de desarrolladores activos alrededor del mundo. Se mejora regularmente, con las actualizaciones que ocurren típicamente varias veces al mes.

RFO Basic tiene una útil ayuda integrada para todas las funciones disponibles y construcciones de lenguaje, y varias docenas de programas de ejemplo completos, inmediatamente disponibles directamente en su dispositivo Android.

RFO Basic es ridículamente sencillo de aprender y usar. No hay profundos conceptos de lenguaje de programación para inculcar, no hay conocimientos complejos de fondo para entender, no hay un enorme IDE de escritorio para instalar, no hay nada Android SDK para aprender, no hay lenguaje JAVA script a código fangoso, no hay aprobación de app store para solicitar o cualquiera de Los típicos obstáculos encontrados al crear programas para dispositivos móviles.

Simplemente descargue la aplicación 1/2 Meg RFO Basic a su teléfono, familiarícese con la referencia de función incluida y programas de ejemplo, y empiece a escribir un código de procedimiento basado en linea de comando simple en un editor de texto. Hay docenas de funciones concisas para administrar los datos, controlar el hardware, interactuar con los usuarios y completar rápidamente muchos tipos de trabajo útil. El intérprete / runtime se instala en menos de un minuto, y puede configurar un PC de escritorio como una máquina de edición de código con un par de minutos adicionales.

RFO Basic es lo suficientemente fácil para principiantes y usuarios de computadoras promedio para operar de inmediato, pero lo suficientemente potente como para una variedad de usos profesionales. Puede tratarlo como una sencilla calculadora o aplicación de utilidad personal para su teléfono, o como un entorno de desarrollo completo para crear aplicaciones comercializables.

Puede escribir secuencias de comandos rápidas en su dispositivo para administrar archivos, ver y editar información de base de datos, procesar texto, descargar datos web, realizar subidas de FTP, tomar fotos, procesar imágenes, acceder fácilmente al reconocimiento de voz y otras funciones de Android, etc.

Lo utilizan para desarrollar juegos gráficos o aplicaciones de red que puede vender en el mercado - y todo lo demás. (Tenga en cuenta que RFO Basic tiene licencia de GPL, por lo que si libera cualquier software comercial que incluya su código, también debe liberar el código fuente).

Los desarrolladores experimentados y los profesionales de TI encontrarán que RFO Basic permite que una amplia variedad de scripts de utilidad se desarrollen y desplieguen en minutos y horas, en lugar de días y semanas, y con una curva de aprendizaje dramáticamente corta.

RFO Basic puede ser entendido inmediatamente por cualquier persona que haya usado cualquier forma de Basic tradicional. Una comunidad entera de desarrolladores y programadores principiantes puede aprovechar sus habilidades existentes en este ambiente familiar y fácil, para crear aplicaciones móviles útiles.

Si eres nuevo en Basic o incluso en la programación en general, no te preocupes. RFO Basic es un subconjunto extremadamente simple de otros lenguajes de programación básicos familiares. Puede leer toda la API y la documentación de referencia en un solo día. Este tutorial proporcionará suficiente comprensión fundamental, ejemplos de código de trabajo y estudios de caso para crear aplicaciones de todo tipo, por completo.

Esta aplicación dispone de un amplio manual en inglés (http://rfo-basic.com/manual/), accesible a través de la web, de la propia app en el móvil y también se puede descargar.


También se puede acceder al manual desde la web: http://rfobasic.com/


2. Introducción: Descarga e instalación de RFO Basic, Hello World


El intérprete de RFO Basic es una aplicación (programa de software) que se ejecuta en su dispositivo Android. Traduce texto escrito en la sintaxis del lenguaje básico de RFO ("código fuente") en aplicaciones que otros usuarios pueden ejecutar en su dispositivo. Para obtener la aplicación gratuita RFO Basic, vaya a:

Http://www.laughton.com/basic/versions/index.html

Vaya al enlace de arriba en el navegador web de su teléfono, descargue la versión más reciente del archivo Basic.apk en su dispositivo Android y ejecute la instalación (alternativamente, podría instalarla en Google Play Store). Una vez que haya instalado RFO Basic, haga clic en "Basic!" Para ejecutarlo, pulse el botón de menú de Android en su teléfono, seleccione "Borrar" y escriba el código siguiente en el área de texto:

"Hola mundo!"
Para ejecutar el código, pulse de nuevo el botón de menú de Android y seleccione "Ejecutar".

Antes de ir más lejos, darle una oportunidad. Descargue RFO Basic y escriba el código de arriba para ver cómo funciona. Es extraordinariamente simple y literalmente toma sólo unos segundos para configurar. Para beneficiarse de este tutorial, es fundamental que escriba o pegue cada ejemplo de código en el intérprete de RFO Basic para ver qué sucede.

3. Varios Ejemplos Simples

3.1 Aplicación Tiny Note Pad

Para acostumbrarse a trabajar con RFO Basic, y para ver lo sencillo que es el código, pruebe esto:

Ejecute la aplicación RFO Basic, pulse el botón de menú de Android, seleccione "Borrar" y escriba el siguiente código en el área del editor de texto:

File.exists b, "temp.txt"
If b = 0 then console.save "temp.txt"
Grabfile s $, "temp.txt"
Text.input r $, s $
print r $
Console.save "temp.txt"

Este programa comprueba primero si el archivo de texto "temp.txt" existe en su dispositivo Android. Si el archivo "temp.txt" no existe, crea un nuevo archivo de texto en blanco denominado "temp.txt". A continuación, lee el contenido del archivo "temp.txt", y permite al usuario editarlo. Finalmente, guarda el texto editado en el archivo "temp.txt". Este pequeño programa es una aplicación de libreta de notas real y útil que puede usar para anotar y guardar información importante de texto de cualquier tipo.

Para guardar el código del programa anterior, pulse el botón de menú de Android, seleccione "Guardar" e ingrese un nombre de archivo (es decir, "edit.bas"). Ejecute el programa pulsando el botón de menú Android y seleccione "Ejecutar". Puede cargar, editar y ejecutar este programa guardado en cualquier momento en RFO Basic pulsando el botón de menú de Android y seleccionando "Cargar".

Si tiene algún problema, puede descargar el código de arriba en http://www.rfobasic.com/edit.bas. Puede probar una versión de trabajo de esta aplicación en http://www.rfobasic.com/edit.apk.

3.2 Aplicación Teeny Timer

Ahora, cree un nuevo archivo .bas vacío (Básico! -> Botón de menú -> Borrar) y escriba el código siguiente:

S = clock ()
Print "El temporizador comenzó en:"; S
Do
     inkey$  k$
     If ((k$ <> "@") & (k$ <> "key 4")) then done = 1
Until done
E = clock()
Print "TIEMPO:"; (E - S) / 1000; " segundos"

Guarde y ejecute el programa. Es una aplicación de cronómetro útil, precisa a milésimas de segundo. Si tiene algún problema con el ejemplo, puede descargar y ejecutar el código completo de http://www.rfobasic.com/timer.bas. Puede probar una versión funcional de esta aplicación en http://www.rfobasic.com/timer.apk.

Como puede ver, los programas útiles de RFO Basic pueden ser muy breves y sencillos de crear.

3.3 Ejemplos en línea

     Hay varios programas de ejemplo interesantes creados por miembros de la comunidad en http://laughton.com/basic/programs/. Puedes conocer mucho sobre RFO basic simplemente explorando el código descargable en esas aplicaciones. De forma predeterminada, cualquier código de programa RFO Basic descargado debe guardarse en la carpeta "/ sdcard / rfo-basic / source /" de su dispositivo Android. 

     Los recursos descargados necesarios para ejecutar los programas (imágenes, archivos de configuración, etc.) deben colocarse en la carpeta "/ sdcard / rfo-basic / data /". Las bases de datos SQLite deben colocarse en la carpeta "/ sdcard / rfo-basic / databases". Más información sobre el código donado por la comunidad RFO Basic está disponible en http://rfobasic.freeforums.org/shared-program-instructions-7-30-11-t125.html.

3.4 Edición y sugerencias de flujo de trabajo

    
En muchos pequeños dispositivos Android, el editor de texto integrado en RFO Basic no es el entorno más cómodo o productivo para editar código. También es útil copiar / pegar código de archivos o sitios web (como este tutorial) desde su computadora de escritorio, directamente en el intérprete de RFO Basic. Una forma de hacerlo es usar un emulador de Android que se ejecuta en su computadora de escritorio. Youwave y Bluestacks son dos emuladores que trabajan con RFO Basic en Windows y Mac OS. Desafortunadamente, los emuladores son programas grandes que utilizan muchos recursos del sistema, por lo que pueden funcionar lentamente en todas las computadoras de escritorio excepto las más potentes.

    
Una opción más eficiente es conectar su dispositivo Android a su computadora de escritorio usando un cable USB, y establecer el tipo de conexión a unidad de disco. Con esto hecho, usted puede corregir y ahorrar el código del programa usando cualquier redactor de textos, después recargarlo y ejecutarlo en RFO Basic!.

    
Una opción inalámbrica es utilizar programas como Wifi File Transfer para configurar un servidor en su teléfono, y luego conectarse usando el navegador web en su PC de escritorio, para transferir archivos editados. Esta es una manera fácil de obtener código de ida y vuelta entre su Android y PC de forma inalámbrica, sin necesidad de configurar ningún software en la máquina de escritorio.

    
Las aplicaciones de explorador de archivos de Android, como el Explorador de archivos ES gratuito, proporcionan otra forma de editar y transferir código. Cargue sus archivos de código editados en un servidor FTP o guárdelos en una carpeta de red compartida (en su PC de escritorio, haga clic con el botón derecho en cualquier carpeta y seleccione "compartir con" para compartirla en su red de área local). A continuación, puede abrir los archivos directamente con el Explorador de archivos ES: proporciona una carga directa y edición sencilla de archivos en servidores FTP y recursos compartidos de LAN. Desde el editor de archivos ES, puede copiar / pegar código en el editor RFO Basic. Esto puede ser una opción útil si varias personas necesitan compartir / editar el mismo código.

    
Si hace un montón de código de edición directamente en su dispositivo Android, puede ser útil utilizar un teclado de software como A.I. Type, que admite Deshacer / Rehacer, teclas de cursor y otras funciones útiles de edición. Este teclado se puede utilizar directamente en el editor de código RFO Basic, pero otros editores como Jota y DroidEdit proporcionan características similares.

    
La herramienta preferida por este autor es Wifi File Transfer. Edita el código usando tu editor de texto de escritorio favorito, guarda y transfiere a la carpeta / sdcard / rfo-basic / source / en tu Android usando Wifi File Transfer, luego vuelve a abrirlo y ejecuta con RFO Basic. (Asegúrese de marcar "Sobrescribir archivos existentes" cuando use este proceso). Este procedimiento es simple, rápido y le permite copiar / pegar / editar / ejecutar entre cualquier PC de escritorio y dispositivo Android en sólo unos segundos, sin cables y sin ninguna configuración de software en el escritorio (Wifi File Transfer no requiere carpetas compartidas, credenciales de inicio de sesión, etc. - sólo un navegador y una conexión de red).

    
Para ejecutar los numerosos ciclos de edición / transferencia / ejecución necesarios para escribir y depurar cualquier tipo de código, es esencial que se convierta perfectamente en casa (y FAST) con al menos una de estas rutinas.

3.5.- Cálculo de los números primos en un intervalo

En este ejemplo no solo vamos a calcular los números primos en un intervalo seleccionable por el usuario, sino también el número de primos en ese intervalo y el tiempo que el dispositivo tarda en calcularlo.

Como ya sabemos los números primos son aquellos que solo son divisibles entre 1 y ellos mismos, por tanto para saber si un número es primo tenemos que dividirlo entre todos los números anteriores a él y comprobar que su resto no es cero. El algoritmo es el siguiente:

REM Start of BASIC! Program
input "Introduce límite inferior", nliminf
input "Introduce límite superior", nlimsup
print "Números primos entre:",nliminf," y ",nlimsup
primo0=1
primo1=1
p=0
s=clock()
for x=nliminf to nlimsup
 for i=1 to x
  if mod(x,i)=0 & x<>i & i>1 then
    primo0=0
    rem print primo0,x,i
  else
   primo1=1
   rem print primo1,x,i
  endif
 next i
 if primo0=1 & primo1=1 then
   print "El número: ";x;" es primo"
   p=p+1
 endif   
 primo0=1
next x
e=clock()
print "Hay ";p;" números primos entre "; nliminf;" y ";nlimsup
print "Tiempo:";(e-s)/1000;" segundos"

El significado de cada variable es el siguiente:

nliminf ----> Límite inferior
nlimsup ----> Límite superior
primo0 ----> Indicador de número no primo. Se pone a 0 cuando el módulo es 0
primo1 ----> Indicador de número primo. Se pone a 1 cuando el módulo es distinto de 0
x ----> Variable que recorre todo el intervalo de números
i -----> Variable que recorre todos los números anteriores al número que se está comprobando
p ----> Contador de los números primos que hay en el intervalo indicado
s ----> Valor del reloj al inicio del programa
e ----> Valor del reloj al final del programa

Ahora vamos a generar un fichero de texto donde vamos a almacenar los números primos en un intervalo a seleccionar por el usuario. Para ello vamos a hacer uso del ejemplo Tiny Note Pad visto anteriormente, al igual que para contar el tiempo hemos hecho uso del ejemplo Teeny Timer.

REM Start of BASIC! Program
li=0
ls=0
input "Introduce límite inferior", li$
input "Introduce límite superior", ls$
print "Números primos entre: ";li$;" y ";ls$
primo0=1
primo1=1
p=0
interval$=li$+"-"+ls$
nombrefile$="Primos" + interval$ +".txt"
print nombrefile$
file.exists b, nombrefile$
if b=0 then console.save nombrefile$
s=clock()
for x=val(li$) to val(ls$)
 for i=1 to x
  if mod(x,i)=0 & x<>i & i>1 then
    primo0=0
    rem print primo0,x,i
  else
   primo1=1
   rem print primo1,x,i
  endif
 next i
 if primo0=1 & primo1=1 then
   print "El número: ";x;" es primo"
   p=p+1
   grabfile s$,nombrefile$
   texto$="El número: "+chr$(x)+" es primo"
   text.open a, filename, nombrefile$
   text.writeln filename,texto$
 endif   
 primo0=1
next x
e=clock()
print "Hay ";p;" números primos entre "; li$;" y ";ls$
print "Tiempo:";(e-s)/1000;" segundos"
console.save nombrefile$


La salida de datos se realiza en ficheros de texto a los que se les asigna en programa el nombre: "Primos"+Intervalo. Un ejemplo de salida serian los números primos del 1 al 1000:

Números primos entre: 1 y 1000
Primos1-1000.txt
(1)(2)(3)(5)(7)(11)(13)(17)(19)(23)(29)(31)(37)(41)(43)(47)(53)(59)(61)(67)(71)(73)(79)(83)(89)(97)(101)(103)(107)(109)(113)(127)(131)(137)(139)(149)(151)(157)(163)(167)(173)(179)(181)(191)(193)(197)(199)(211)(223)(227)(229)(233)(239)(241)(251)(257)(263)(269)(271)(277)(281)(283)(293)(307)(311)(313)(317)(331)(337)(347)(349)(353)(359)(367)(373)(379)(383)(389)(397)(401)(409)(419)(421)(431)(433)(439)(443)(449)(457)(461)(463)(467)(479)(487)(491)(499)(503)(509)(521)(523)(541)(547)(557)(563)(569)(571)(577)(587)(593)(599)(601)(607)(613)(617)(619)(631)(641)(643)(647)(653)(659)(661)(673)(677)(683)(691)(701)(709)(719)(727)(733)(739)(743)(751)(757)(761)(769)(773)(787)(797)(809)(811)(821)(823)(827)(829)(839)(853)(857)(859)(863)(877)(881)(883)(887)(907)(911)(919)(929)(937)(941)(947)(953)(967)(971)(977)(983)(991)(997) 
Hay 169.0 números primos entre 1 y 1000
Tiempo:5.883 segundos
Nro. operaciones: 21614.0
El programa también nos dice el recuento de números primos en ese intervalo y el tiempo que tarda el dispositivo en ejecutar el programa. Mientras mayor es el intervalo y más altos son los números, mayor es el tiempo de ejecución.
Este programa se puede mejorar haciendo que al encontrar un divisor para un número, salga del bucle y pase al siguiente, ya que ahora se recorre todos los números anteriores al número que se está comprobando si es primo. Para número mayores a 10000, tiene que realizar más de 10000 comprobaciones por cada número, lo cual incrementa exponencialmente el número de cálculos a realizar.

Para descargar el fichero: Primos-intervalo.bas

3.5.- Cálculo para comprobar si un números es primo

Otro interesante programa que he realizado es la comprobación de si un número introducido por el usuario es primo o no. En caso de no ser primo nos muestra todos sus divisores. El código para realizar este sencillo programa es el siguiente:
REM Start of BASIC! Program

input "Introduce número", nro$
primo0=1
primo1=1
p=0
s=clock()
print "Calculando... "
x=val(nro$)
 for i=1 to x
  if mod(x,i)=0 & x<>i & i>1 then
    primo0=0
    print x;" entre: ";i;" da: ";x/i
  else
   primo1=1
   rem print primo1,x,i
  endif
 next i
 if primo0=1 & primo1=1 then
   print "El número ";x;" es primo"
 else
   print "El número: ";x;" NO es primo"
 endif   
 primo0=1
e=clock()
print "Tiempo:";(e-s)/1000;" segundos"

4. Fundamentos del Lenguaje Basic de RFO

4.1 Funciones / Comandos      Como con cualquier lenguaje de programación moderno, para usar RFO Basic, necesitas aprender a usar "comandos" (alternativamente llamados "funciones" o "métodos", en varios lenguajes de programación). Los comandos son palabras que realizan acciones. Típicamente procesan datos de alguna manera. Las palabras de comando son seguidas por los "parámetros" de los datos (también llamados "argumentos"). En RFO Basic, los parámetros múltiples se separan por comas. Escriba y ejecute este comando en la ventana de código RFO Basic, para ver cómo funciona:
popup "Hello world!",0,0,1
Observe cómo el cambio de los parámetros altera el funcionamiento del comando:
popup "Moved over, and shorter duration...",50,50,0
El comando "print" es muy importante. Puede imprimir un solo elemento, ya sea un número o un texto:
print "five"
print 5 
Puede imprimir varios elementos, separados por comas:
print "one", "two", "three"
Puede imprimir varios elementos al lado del otro, utilizando puntos y comas:

print "one"; "two"; "three"

Si finaliza un comando de impresión con un punto y coma, RFO Basic esperará el siguiente comando de impresión para mostrar realmente cualquier dato:

print "waiting...";
pause 2000
print "done"
Otro comando inmediatamente útil es "console.save". Console.save guarda la salida de la consola de RFO Basic (cualquier cosa que se haya impreso en el programa actual), al archivo especificado:

print "test"
console.save "temp.txt"

Muchos de los comandos en RFO Basic siguen el formato: category.action. Por ejemplo, el comando GPS "gps.latitude" obtiene su latitud actual, "gps.altitude" obtiene su altitud actual. El comando de audio "audio.play" comienza a reproducir un sonido, y "audio.record" comienza a grabar un sonido, etc.

Nota:
"Técnicamente, hay una diferencia entre un "comando" y una "función" en RFO Basic (las funciones requieren paréntesis y siempre devuelven un valor), pero para los propósitos de este tutorial, utilizaremos el término "function" para referirnos a todas las palabras de acción, funciones y comandos."

4.2 Comentarios

     Los comentarios son pequeñas notas legibles por humanos, agregadas a los programas, que son completamente ignoradas por el intérprete de lenguaje de computadora. Su propósito es recordar a los programadores lo que una pieza de código en particular hace, y están destinados a ser sólo legibles por las personas. En RFO Basic, hay tres tipos de comentarios:

print "Hello"   % all text after a percent sign is IGNORED

! Exclamation points force entire lines to be ignored

!! 
You can comment any number of multiple lines by surrounding
them with double exclamation points.
Nothing in this program is executed, except for the first
'print "Hello"' code.
!!
 


4.3 Variables

     Las variables son palabras que un programador elige para etiquetar y 
representar los datos almacenados, para que los datos puedan ser referidos y utilizados de nuevo más tarde en un programa. Para crear una variable de etiqueta, los programadores eligen cualquier combinación de letras y números, siempre y cuando la variable comience con una letra, y no contenga ningún carácter especial. Las variables de texto, o "cadenas" en RFO Basic, generalmente van seguidas por el carácter "$". Una palabra seguida de un signo "=" establece una etiqueta de variable:

person$ = "Juan"

Junto con las funciones, las variables son quizás los conceptos más fundamentales y omnipresentes de toda la programación, independientemente del idioma. Después de que se haya ejecutado el código anterior, la etiqueta "person$" se puede usar en cualquier lugar (sin el signo igual), para representar el texto "Juan":
 
popup person$,0,0,1 
 
Los valores de las variables se pueden cambiar en cualquier punto de un programa, es una de las principales razones de su uso:
 
person$ = "Dave"
popup person$,0,0,1 

En RFO Basic, las variables NO son sensibles a mayúsculas y minúsculas:
 
popup person$,0,0,1
popup PERSON$,0,0,1
popup PeRsOn$,0,0,1 

Para el intérprete de RFO Basic, las tres líneas anteriores son iguales.
 
Las variables son extremadamente importantes en cada tipo de programación porque representan datos variables ("variables"). Los datos introducidos por un usuario, leídos de un archivo, devueltos por un sensor, etc., pueden ser representados por variables. Usted podría almacenar el texto entero de un libro leído de un servidor web en una variable etiquetada "libro$". Podría leer los nombres de archivo contenidos en una carpeta en su tarjeta SD y darle a esa lista la etiqueta "files$". Usted podría pedir a su usuario para seleccionar un MP3 de su sistema de archivos y asignarle la variable etiqueta "song$". En cualquiera de estos casos, puede utilizar las etiquetas verificables que ha proporcionado los datos para cargar, guardar, mostrar, manipular y procesar los datos representados, todos utilizando una única palabra variable.

4.4 Valores de retorno de la función
 
La mayoría de las funciones producen valores de "retorno". Los valores de retorno son los datos de salida producidos cuando una función procesa cualquier dado de entrada dado. Los datos procesados y devueltos por una función normalmente se almacenan en variables:
 
lowered = lower$ ("THIS FUNCTION CONVERTS TEXT TO LOWERCASE.")
print lowered 

Esta función convierte texto a minúsculas. En algunos casos, la salida (valor de retorno) de una función se puede utilizar directamente como la entrada de otra función:

print lower$ ("THIS FUNCTION CONVERTS TEXT TO LOWERCASE.")

! The previous line contains 2 functions: 'print' and 'lower$'
! The output of the lower$ function is used as the input
! parameter of the print function.
 
En RFO Basic, el valor o valores de retorno de las funciones (comandos) se especifican con mayor frecuencia como parámetros (colocados en la lista de parámetros) inmediatamente después de la palabra de función. La siguiente función "grabfile" almacena el texto leído del archivo especificado, en la variable arbitrariamente elegida "s$":
 
print "Hello World!"       % this prints some text
console.save "temp.txt"    % this saves the printed text to a file
grabfile s$, "temp.txt"    % this reads the file and stores the 
                           %   returned data in the variable s$
print s$                   % this prints the contents of the variable 

Los valores de retorno generados por las numerosas funciones de RFO Basic pueden 
ser utilizados en sus programas para lograr metas útiles. La función "input" le permite solicitar una sola línea de texto, o un número, del usuario:
 
input "Enter some text", s$   %text input by user is stored in variable s$
print s$ 

Observe la siguiente línea contiene el valor de retorno "n", sin el carácter "$". por lo tanto, N es tratado como una variable de número:
 
input "Enter a number", n
print n 

La función "input" tiene un parámetro opcional que le permite mostrar algún texto por defecto en el mensaje solicitante:
 
input "Enter your name", s$, "John"   % the "$" in s$ means that it's text
print s$
 
La función "text.input" permite al usuario ingresar, editar y guardar grandes cantidades de texto. El primer parámetro es una variable de cadena que contiene el texto editado final emitido por la función. El segundo parámetro contiene un texto inicial que aparecerá en la ventana del editor:
 
text.input r$, "Edit this text"       % user edited text is stored in r$
print r$ 

4.5 Una variedad de ejemplos de funciones útiles

Aquí hay algunos ejemplos más que demuestran cómo realizar acciones útiles y cómo procesar los datos de maneras útiles, utilizando funciones / comandos. Trate de escribir o pegar cada uno de ellos en el intérprete de RFO Basic, para ver cómo funcionan:

La función de tono usa 2 parámetros, tono y duración, y reproduce un tono:
tone 440, 2000  

La función file.rename usa 2 parámetros, los nombres antiguo y nuevo del archivo, y cambia el nombre del archivo antiguo al nuevo nombre de archivo en el sistema de archivos de Android:
 
    file.rename "oldname.txt", "newname.txt"

! The clipboard.get function takes 1 parameter, a variable name assigned
! to the contents retrieved from the device clipboard:

    clipboard.get c$
    print c$         % this prints the data returned by the function above

! The tts.init function prepares for the use of text-to-speach functions
! No parameter is required:

    tts.init

! The tts.speak function takes 1 parameter, some text to speak:

    tts.speak "I am alive"

! This code reads the current text in the Android clipboard:

    clipboard.get c$
    tts.init
    tts.speak c$

! The audio.record.start takes 1 parameter, the name of a file to record
! to:

    audio.record.start "record.3gp"

! The pause function takes 1 parameter, the amount of time to wait (in
! milliseconds):

    pause 5000

! The audio.record.stop function doesn't take any parameters.  It just
! stops the recording previously started:

    audio.record.stop

! The audio.load function takes 2 parameters, the name of a "pointer"
! number used to refer to a specified audio file, and the name of the
! specified audio file:

    audio.load s, "record.3gp"

! The audio.play function plays the file specified by the pointer number
! created in the previous function:

    audio.play s
    pause 5000

! The clock() function doesn't take any parameter.  It returns the number
! of milliseconds since your device was turned on:

    s = clock()

! This prints the data contained in the numeric variable created above:

    print s     

! The device function takes 1 parameter, the name of a string variable to
! store returned information about your device:

    device s$

! This line prints the data contained in the string variable created
! above:

    print s$    

! The gps.open function doesn't take any parameters.  It just prepares for
! the use of the GPS function:

    gps.open

! The gps.latitude and gps.longitude functions each take 1 parameter,
! a variable name to store the returned latitude and longitude values:

    gps.latitude l1
    gps.longitude l2

! The gps.close function doesn't take any parameters.  It just closes
! the gps device opened above:

    gps.close

! This prints the longitude and latitude values stored in the return
! variables created above:

    print "Your longitude and latitude:  "; l1; ", "; l2

! This assigns some text to a new string variable:

    s$ = "three blind mice"

! The replace function takes 3 parameters, the name of an input AND return
! string variable in which to find and replace text, the text to find and
! replace, and the replacement text - all contained inside parentheses:

    replace$ (s$, "blind", "sexy")

! This prints the replaced text string returned by the function above:

    print s$

! The ftp.open function takes 4 parameters, the URL of an FTP server, the
! port to open, a username, and a password:

    ftp.open "ftp.site.com", 21, "username", "password"

! The ftp.put function takes 2 parameters, the name of a local file to
! tranfer to the remote FTP server, and the path/filename to create and
! send to on the server:

    ftp.put "temp.txt", "/public_html/temp.txt"

! The ftp.close function doesn't take a parameter.  It just closes the
! currently open FTP connection:

    ftp.close

! The graburl function takes 2 parameters, a string variable name in which
! to save the returned data from a specified URL, and a URL to read:

    graburl w$, "http://site.com/temp.txt"

! This prints the returned data read from the URL and stored in the
! variable created above:

    print w$

! The is_in function takes 2 parameters, a string to search for, and a
! string to search within.  It returns a value of 1 if the search string
! is found within the 2nd string, 0 if not found:

    q = is_in ("blind", "three blind mice")

! This line prints "It's in there" if the search string above is found
! (if the returned value is not 0):

    if q <> 0 then print "It's in there"

! The kb.show function shows Android's on-screen keyboard.  It does not
! take any parameters:

    kb.show

! The kb.hide function hides Android's on-screen keyboard.  It does not
! take any parameters:

    kb.hide

! The sqr() function takes 1 numeric parameter, between parentheses, and
! returns the square root.  The returned value can be assigned a variable
! name:

    s = sqr(16)
    print s

! This line does the exact same thing as the previous 2 lines.  It just
! prints the value of the sqr() function (the return value of the sqr()
! function is used as the parameter of the print function):

    print sqr(16)

! The array.load function creates a type of item list.  It takes 1 or more
! parameters, a variable name to assign to the list, and several items
! (in the case below, numbers), to add to the list:

    array.load p[], 0, 300, 200, 300, 200, 300 

! The vibrate function takes 2 parameters, an array of durations to pause
! and vibrate, and a number to indicate whether that vibration pattern
! should be repeated (-1 indicates no repeat):

    vibrate p[], -1

! The gr.camera.manualshoot takes 1 parameter, a "pointer" number used to
! refer to the photo image taken:

    gr.camera.manualshoot p

! After the above function, look at the photo
! /sdcard/rfo-basic/data/image.jpg on your phone.  The results are stored
! in that temporary file (later in the tutorial, you'll learn how to use
! the returned pointer value to display and manipulate the image in
! graphic layouts).