Skip to content

yotta / pictogram

Go to a project
Commit c01274f1 by Fernando Martínez Santiago
Options

Merge branch 'develop' of http://scm.ujaen.es/softuno/pictogram into fernando_branch

parent 5c9d3a95
Inline Side-by-side
Showing with 177 additions and 6299 deletions
.gitignore
......@@ -43,8 +43,14 @@ sails/upload.zip
###########
.idea
android/Pictogram/.idea
android/Pictogram/app/app.iml
android/Pictogram/commonlibrary/commonlibrary.iml
android/Pictogram/tablet/tablet.iml
android/Pictogram/watch/watch.iml
android/Pictogram/Pictogrammar.iml
android/Pictogram/commonlibrary/build
android/Pictogram/tablet/build
android/Pictogram/watch/build
android/Pictogram/build
# OS generated files #
######################
......
android/Pictogram/app/proguard-rules.pro deleted 100644 → 0
# Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in e:\Users\Fernando\AppData\Local\Android\sdk/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the proguardFiles
# directive in build.gradle.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# Add any project specific keep options here:
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}
android/Pictogram/app/src/main/java/com/yottacode/net/FakeSSLTrustManager.java deleted 100644 → 0
package com.yottacode.net;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.X509TrustManager;
/**
* Created by amontejo on 27/01/16.
*/
public class FakeSSLTrustManager implements X509TrustManager {
@Override
public void checkClientTrusted(final X509Certificate[] arg0,
final String arg1) throws CertificateException {
// TODO Auto-generated method stub
}
@Override
public void checkServerTrusted(final X509Certificate[] arg0,
final String arg1) throws CertificateException {
// TODO Auto-generated method stub
}
@Override
public final X509Certificate[] getAcceptedIssuers() {
// TODO Auto-generated method stub
return null;
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/net/SSLDummyContext.java deleted 100644 → 0
package com.yottacode.net;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import android.util.Log;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
class RelaxedHostNameVerifier implements HostnameVerifier {
public boolean verify(String hostname, SSLSession session) {
return true;
}
}
public class SSLDummyContext {
static SSLContext mySSLContext = null;
public static void init(boolean ssl) {
try {
mySSLContext = SSLContext.getInstance("TLS");
if (!ssl) {
mySSLContext.init(null, new TrustManager[]{new FakeSSLTrustManager()}, new SecureRandom());
HttpsURLConnection.setDefaultHostnameVerifier(new RelaxedHostNameVerifier());
HttpsURLConnection.setDefaultSSLSocketFactory(mySSLContext.getSocketFactory());
} else
mySSLContext.init(null, null, null);
} catch (NoSuchAlgorithmException e) {
Log.e(e.getClass().getName(), e.getClass().getCanonicalName() + ": " + e.getMessage());
} catch (KeyManagementException e) {
Log.e(e.getClass().getName(), e.getClass().getCanonicalName() + ": " + e.getMessage());
}
}
public static SSLContext get() {
return mySSLContext;
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/net/SailsSocketsIO.java deleted 100644 → 0
package com.yottacode.net;
import android.util.Log;
import com.github.nkzawa.socketio.client.Ack;
import com.github.nkzawa.socketio.client.IO;
import com.github.nkzawa.socketio.client.Socket;
import com.github.nkzawa.emitter.Emitter;
import org.json.JSONException;
import org.json.JSONObject;
import java.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import java.security.SecureRandom;
/**
* This listener logs all received answers from the message it is registered to
* It is usually not used
*/
class DefaultListener implements Emitter.Listener {
private String msg;
public DefaultListener(String msg) {
super();
this.msg = msg;
}
@Override
public void call(Object... args) {
Log.d(this.getClass().getName(),"Received message:"+this.msg);
for (Object arg : args)
Log.d(this.getClass().getName(), "Argument:" + arg);
}
}
/**
* Websocket Room based on Socket IO
* @author Fernando Martinez Santiago
* @version 1.0
*/
public class SailsSocketsIO {
private Socket socket=null;
private static final String EMIT_METHOD="post";
/**
* Registers a connection listener to default connection messages
* @param socket
* @param connectListener
*/
private void registerMessages(Socket socket, Emitter.Listener connectListener, Emitter.Listener errorListener) {
socket.on(Socket.EVENT_CONNECT, connectListener)
.on(Socket.EVENT_CONNECT_ERROR, errorListener)
.on(Socket.EVENT_CONNECT_TIMEOUT, errorListener)
.on(Socket.EVENT_ERROR, errorListener)
.on(Socket.EVENT_DISCONNECT, errorListener);
}
/**
* Registers a connection listener to a given message
* @param message
* @param listener
*/
public void registerMessage(String message, Emitter.Listener listener) {
Log.d(this.getClass().getName(), " Listening:"+message);
socket.on(message, listener);
}
public SailsSocketsIO(String sails_socket_io_url, String ptransport, Emitter.Listener connectListener, Emitter.Listener errorListener) {
final String sdk_version= "0.11.0";
final String sdk_module="node";
final String sdk_language="java";
final String transport=ptransport;
final String query_version =
"__sails_io_sdk_version"+"=" + sdk_version + '&' +
"__sails_io_sdk_platform"+"=" + sdk_module+ '&' +
"__sails_io_sdk_language" + '=' + sdk_language;
try {
SSLContext mySSLContext = SSLDummyContext.get();
IO.setDefaultSSLContext(mySSLContext);
IO.Options opts = new IO.Options();
opts.forceNew = true;
opts.reconnection = false;
opts.sslContext = mySSLContext;
opts.secure=true;
opts.query = query_version;
opts.transports = new String[] {transport};
this.socket = IO.socket(sails_socket_io_url, opts);
this.socket.connect();
this.registerMessages(socket, connectListener, errorListener);
} catch (URISyntaxException e) {
Log.e(e.getClass().getName(), e.getClass().getCanonicalName()+": "+e.getMessage() );
}
}
public void emit(String msg, Object params, Ack ack) throws JSONException {
JSONObject obj=new JSONObject().put("url", msg).put("data", params);
Log.d(this.getClass().getName(), "Emitted messsage:" + obj);
socket.emit(this.EMIT_METHOD, obj, ack);
}
public void destroy() {
this.socket.disconnect();
this.socket.off();
}
}
android/Pictogram/app/src/main/java/com/yottacode/net/iRestapiListener.java deleted 100644 → 0
package com.yottacode.net;
import org.json.JSONArray;
import org.json.JSONObject;
/**
* This interface specifies which are the methods to be implemented by classes receiving
* responses to API requests.
*
* Generally, it is extended by Activities from which API requests are performed
*
* @author dofer
*/
public interface iRestapiListener {
public void preExecute();
public void result(JSONArray result);
public void result(JSONObject result);
public void error(Exception e);
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/action/Action.java deleted 100644 → 0
package com.yottacode.pictogram.action;
import android.util.Log;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
/**
* User actions that happens when the user is online --> they are sent to the server by websockets (Room class)
* It is required, inter alia, to support session state diagram such
* as is depicted at http://scm.ujaen.es/files/note/1042/Estados_y_acciones.pdf
* and http://scm.ujaen.es/softuno/pictogram/wikis/LUActions
* @author Fernando Martinez Santiago
* @version 1.0
* @see Room
*/
public abstract class Action {
protected String type;
/**
* It creates an action for any user, both online and offline actions.
*
* @param type
*/
public Action(String type){
this.type=type;
}
public String get_type() { return this.type;}
public abstract String get_action();
protected JSONObject get_json() {
final String param_id_stu="id_stu";
final String param_id_sup="id_sup";
final String param_id_dev="id_dev";
final String param_timestamp="timestamp";
final Date currentTime = new Date();
SimpleDateFormat datetime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSZ");
try {
JSONObject jsonObject = new JSONObject()
.put(param_id_stu, PCBcontext.getPcbdb().getCurrentUser().get_id_stu())
.put(param_timestamp, datetime.format(currentTime));
Log.d("TIMESTAMP-----------> ", datetime.format(currentTime));
if (PCBcontext.getPcbdb().getCurrentUser().has_supervisor())
jsonObject.put(param_id_sup,PCBcontext.getPcbdb().getCurrentUser().get_id_sup());
//TODO Decidir qué almacenar con DEVICE
//if (PCBcontext.getDevice().getDeviceID()!=null)
//jsonObject.put(param_id_dev, PCBcontext.getDevice().getDeviceID());
return jsonObject;
}catch(JSONException e) {
Log.e(this.getClass().getCanonicalName(),e.getMessage());
return null;
}
}
/**
*
* @return the whole description of the action, including the action type (required for sending batch actions,
* more info at http://scm.ujaen.es/softuno/pictogram/wikis/RestapivalidActionsBatch)
*/
public JSONObject getDescription() {
final String param_action= "action";
final String param_attributes= "attributes";
try {
return (new JSONObject().put(param_action, this.type)
.put(param_attributes, this.get_json()));
} catch (JSONException e) {
Log.e(this.getClass().getCanonicalName(),e.getMessage());
}
return null;
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/action/ActionLog.java deleted 100644 → 0
package com.yottacode.pictogram.action;
import android.util.Log;
import com.yottacode.net.iRestapiListener;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.Hashtable;
import java.util.Vector;
/**
* Created by emblanco on 5/10/15.
* Modified by Fernando on 10/11/15
* More info at http://scm.ujaen.es/softuno/pictogram/wikis/LUActions
*/
public class ActionLog implements iRestapiListener {
Vector<JSONObject> actions_buffer;
public ActionLog() {
actions_buffer=PCBcontext.getPcbdb().loadActions();
if (PCBcontext.getNetService().online()) batch();
}
// String constant for logs
private static final String LOG_TAG = ActionLog.class.getCanonicalName();
/**
* Online action. It is send by using web sockets
* @param action
*/
public void log(Action action) {
if (PCBcontext.getRoom().inRoom())
PCBcontext.getRoom().emit(action);
else {
// If there is no room, the action is stored into the local DB
PCBcontext.getPcbdb().insertAction(action);
actions_buffer.add(action.getDescription());
Log.i(this.getClass().getCanonicalName(), " Batch action included: " + action.getDescription());
}
}
public void batch() {
if (!actions_buffer.isEmpty()) {
Hashtable<String, String> params=new Hashtable<>(1);
String url="stu/actions_batch";
JSONArray actions= new JSONArray();
for (JSONObject action: actions_buffer)
actions.put(action);
//actions= "{actions: [" + actions.substring(1) + "]}";
try {
params.put("json",new JSONObject().put("actions",actions).toString());
} catch (JSONException e) {
e.printStackTrace();
Log.e(this.getClass().getCanonicalName(), " Batch action error: " + e.getMessage());
}
Log.i(this.getClass().getCanonicalName()," Sending batch actions: "+url+": "+actions);
PCBcontext.getRestapiWrapper().ask(url, params, "post", true, this);
}
}
@Override
public void preExecute() {
}
@Override
public void result(JSONArray result) {
}
@Override
public void result(JSONObject result) {
try {
Log.i(this.getClass().getName(),
result.has("total") ? "Uploaded actions (batch):" + result.getString("total")
: "Error uploading actions. Message from server: "+result.getString("error"));
}catch (JSONException e) {
Log.e(this.getClass().getCanonicalName(),e.getLocalizedMessage());
}
PCBcontext.getPcbdb().deleteActions();
actions_buffer.clear();
}
@Override
public void error(Exception e) {
Log.e(this.getClass().getCanonicalName(),"Error:"+e.getMessage()+" on actions="+this.actions_buffer);
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/action/PictoAction.java deleted 100644 → 0
package com.yottacode.pictogram.action;
import android.util.Log;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
/**
* User actions regarding a pictogram that happens when the user is online --> they are sent to the server by websockets (Room class)
* It is required, inter alia, to support session state diagram such
* as is depicted at http://scm.ujaen.es/files/note/1042/Estados_y_acciones.pdf
* and http://scm.ujaen.es/softuno/pictogram/wikis/LUActions
* @author Fernando Martinez Santiago
* @version 1.0
* @see Room
*/
public abstract class PictoAction extends Action {
private Picto picto;
private float gps_lat;
private float gps_lon;
/**
* It creates an action for any user regarding a picto, both online and offline actions.
*
* @param type
* @param picto
*/
public PictoAction(String type, Picto picto){
super(type);
this.picto=picto;
}
@Override
public JSONObject get_json(){
final String param_picto="picto";
try {
return super.get_json().put(param_picto, this.get_json_picto());
}catch(JSONException e) {
Log.e(this.getClass().getCanonicalName(),e.getLocalizedMessage());
return null;
}
}
public JSONObject get_json_picto() throws JSONException {
final String param_id_json="id";
final String param_picto="picto";
final String param_expression="expression";
final String param_expr_lang="lang";
final String param_expr_text="text";
final String param_attrs="attributes";
final String param_picto_id="id";
final String param_picto_uri="uri";
final String param_picto_cat="category";
JSONObject subsubPicto = new JSONObject().put(param_picto_id, picto.get_id())
.put(param_picto_uri, picto.get_url())
.put(param_picto_cat, picto.get_category());
JSONObject attributes = new JSONObject(picto.get_json_attrs());
JSONObject expression = new JSONObject().put(param_expr_lang,PCBcontext.getPcbdb().getCurrentUser().get_lang_stu())
.put(param_expr_text,picto.get_translation());
JSONObject subPicto = new JSONObject().put(param_id_json, 1470)
.put(param_picto, subsubPicto)
.put(param_expression,expression)
.put(param_attrs, attributes);
return subPicto;
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/action/PictosAction.java deleted 100644 → 0
package com.yottacode.pictogram.action;
import android.util.Log;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
/**
* User actions regarding a pictogram that happens when the user is online --> they are sent to the server by websockets (Room class)
* It is required, inter alia, to support session state diagram such
* as is depicted at http://scm.ujaen.es/files/note/1042/Estados_y_acciones.pdf
* and http://scm.ujaen.es/softuno/pictogram/wikis/LUActions
* @author Fernando Martinez Santiago
* @version 1.0
* @see Room
*/
public class PictosAction extends Action {
LinkedList<Picto> pictos;
private float gps_lat;
private float gps_lon;
//Pictos Action types
private static final String SHOW="Show";
private static final String ACTION="/stu/action";
/**
* It creates an action for any user regarding a set of pictos, both online and offline actions.
*
* @param pictos
*/
public PictosAction( LinkedList<Picto> pictos){
super(SHOW);
this.pictos=pictos;
}
@Override
public JSONObject get_json() {
final String param_pictos="pictos";
try{
JSONArray ja = new JSONArray();
for(Picto picto : pictos) {
JSONObject jsonpicto = get_json_picto(picto);
ja.put(jsonpicto);
}
return super.get_json().put(param_pictos, ja);
} catch (JSONException e) {
Log.e(PictosAction.class.getCanonicalName(),e.getMessage());
return null;
}
}
private JSONObject get_json_picto(Picto picto) throws JSONException {
final String param_id_json="id";
final String param_picto="picto";
final String param_attrs="attributes";
final String param_picto_id="id";
final String param_picto_uri="uri";
final String param_picto_cat="category";
JSONObject subsubPicto = new JSONObject().put(param_picto_id, picto.get_id())
.put(param_picto_uri, picto.get_url())
.put(param_picto_cat, picto.get_category());
JSONObject attributes = new JSONObject(picto.get_json_attrs());
// Here add sup, dev...
JSONObject subPicto = new JSONObject().put(param_id_json, 1470)
.put(param_picto, subsubPicto)
.put(param_attrs, attributes);
return subPicto;
}
public String get_action() {return ACTION;}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/action/Room.java deleted 100644 → 0
package com.yottacode.pictogram.action;
import android.util.Log;
import com.github.nkzawa.emitter.Emitter;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import com.github.nkzawa.socketio.client.Ack;
import com.yottacode.pictogram.dao.PCBDBHelper;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.net.SailsSocketsIO;
import com.yottacode.pictogram.tools.PCBcontext;
import java.sql.SQLDataException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.LinkedList;
/**
* Websocket Room based on SailsSocketsIO
* It is required, inter alia, to support session state diagram such
* as is depicted at http://scm.ujaen.es/files/note/1042/Estados_y_acciones.pdf
* and http://scm.ujaen.es/softuno/pictogram/wikis/LUActions
* @author Fernando Martinez Santiago
* @version 1.0
*/
public class Room {
protected SailsSocketsIO socket=null;
protected boolean inRoom=false;
protected Hashtable<String, Emitter.Listener> listeners;
public Room( ) {
listeners=new Hashtable<>();
reconnect();
}
private JSONObject common_data(String action, JSONObject attributes) throws JSONException {
final String action_param="action";
final String attributes_param="attributes";
return new JSONObject().put(action_param, action).put(attributes_param, attributes);
}
public void emit(final Action action) {
String token=PCBcontext.getRestapiWrapper().getToken();
final String token_param="token";
Log.d(this.getClass().getName(), "Action: " + action.get_type() + " / Attributes emitted: " + action.get_json().toString());
try{
this.socket.emit(action.get_action(), this.common_data(action.get_type(), action.get_json()).put(token_param, token), new Ack() {
@Override
public void call(Object... args) {
for (Object arg : args)
Log.d(this.getClass().getName(), "Ack messsage:" + arg);
}
});
} catch (JSONException e) {
Log.e(this.getClass().getCanonicalName(), e.getClass().getCanonicalName() + e.getMessage() + "--" + e.getLocalizedMessage());
}
}
/**
* Reconnect to the room. It is useful if the server connection is lost for a time
*/
public void reconnect() {
final String transport="polling";
if (this.socket!=null) this.socket.destroy();
this.socket=new SailsSocketsIO(PCBcontext.getRestapiWrapper().getServer(), transport, new Emitter.Listener() {
@Override
public void call(Object... args) {
Log.i(this.getClass().getName(), "Reconnect successful");
subscribe();
listen_again();
inRoom=true;
}
}, new Emitter.Listener() {
@Override
public void call(Object... args) {
Log.i(this.getClass().getName(), "Reconnect unsuccesful: "+args[0]);
inRoom=false;
}
});
}
public boolean inRoom() {return this.inRoom;}
public void listen(String msg, Emitter.Listener listener) {
this.socket.registerMessage(msg, listener);
this.listeners.put(msg, listener);
}
private void listen_again() {
for (String msg: this.listeners.keySet()) {
Log.i(this.getClass().getName(), "Listening to "+msg);
this.socket.registerMessage(msg, this.listeners.get(msg));
}
}
void subscribe() {
try {
SubscribeAction action = new SubscribeAction();
this.emit(action);
}catch (Exception e) {
Log.e(this.getClass().getCanonicalName(), e.getMessage());
}
}
public void finalize() throws java.lang.Throwable {
super.finalize();
if (this.socket!=null) this.socket.destroy();
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/action/SubscribeAction.java deleted 100644 → 0
package com.yottacode.pictogram.action;
import com.yottacode.pictogram.dao.Picto;
/**
* User actions regarding a pictogram that happens when the user is online --> they are sent to the server by websockets (Room class)
* It is required, inter alia, to support session state diagram such
* as is depicted at http://scm.ujaen.es/files/note/1042/Estados_y_acciones.pdf
* and http://scm.ujaen.es/softuno/pictogram/wikis/LUActions
* @author Fernando Martinez Santiago
* @version 1.0
* @see Room
*/
public class SubscribeAction extends Action {
//Picto Action types
public static final String SUBSCRIBE="subscribe";
public static final String ACTION="/stu/subscribe";
public SubscribeAction( ){
super(SUBSCRIBE);
}
public String get_action() {return ACTION;}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/action/TalkAction.java deleted 100644 → 0
package com.yottacode.pictogram.action;
import android.util.Log;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONException;
import org.json.JSONObject;
/**
* User actions regarding a pictogram that happens when the user is online --> they are sent to the server by websockets (Room class)
* It is required, inter alia, to support session state diagram such
* as is depicted at http://scm.ujaen.es/files/note/1042/Estados_y_acciones.pdf
* and http://scm.ujaen.es/softuno/pictogram/wikis/LUActions
* @author Fernando Martinez Santiago
* @version 1.0
* @see Room
*/
public class TalkAction extends PictoAction {
//Picto Action types
public static final String ADD="Add";
public static final String DELETE="Delete";
public static final String SELECT="Select";
private static final String ACTION="/stu/action";
public TalkAction(String type, Picto picto){
super(type, picto);
}
public String get_action() {return ACTION;}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/action/VocabularyAction.java deleted 100644 → 0
package com.yottacode.pictogram.action;
import android.util.Log;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONException;
import org.json.JSONObject;
/**
* User actions regarding a pictogram that happens when the user is online --> they are sent to the server by websockets (Room class)
* It is required, inter alia, to support session state diagram such
* as is depicted at http://scm.ujaen.es/files/note/1042/Estados_y_acciones.pdf
* and http://scm.ujaen.es/softuno/pictogram/wikis/LUActions
* @author Fernando Martinez Santiago
* @version 1.0
* @see Room
*/
public class VocabularyAction extends PictoAction {
//Picto Action types
public static final String ADD="add";
public static final String ALTERATTRS="update";
private static final String ACTION="/stu/vocabulary";
public VocabularyAction(String type, Picto picto){
super(type, picto);
}
public String get_action() {return ACTION;}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/dao/Device.java deleted 100644 → 0
package com.yottacode.pictogram.dao;
import android.content.ContentValues;
import android.content.Context;
import android.content.res.AssetManager;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.AsyncTask;
import android.util.Log;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Vector;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.gui.LoginActivity;
import com.yottacode.pictogram.tools.Img;
import com.yottacode.pictogram.net.ImgDownloader;
import com.yottacode.pictogram.net.iImgDownloaderListener;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONException;
/**
* Data Access Object to manage Pictogram Communicator Board database regarding App information that is not user-dependent
* This class requires:
* The script to create the DB allocated in res/raw/pcbdb_create.sql
* The entries db_name and db_script_error in strings.xml
*
* @author Fernando Martinez Santiago
* @version 1.1
*/
public class Device extends SQLiteOpenHelper {
Context context;
final static class PARAMS {
static String keyword="key";
static String deviceID="deviceID";
static String serial="serial";
static String stu_id="last__stu_id";
static String sup_id="last__sup_id";
}
/**
* Create a helper object to create, open, and/or manage a database.
*
* @param context the context of the activity
* @param factory null
* @param version 1
*/
public Device(Context context, CursorFactory factory, int version) {
super(context, DeviceHelper.getDBName(context), factory, version);
if (DeviceHelper.force_create(context)) {
Log.i(this.getClass().getCanonicalName(),"Forcing create new Database "+DeviceHelper.getDBName(context));
context.deleteDatabase(DeviceHelper.getDBName(context));
Log.i(this.getClass().getCanonicalName(), "Database dropped");
}
this.context = context;
}
/**
* Set the value of a param.
*
* @return serial the official Yotta device ID or null if it is not specified
*/
private void setParam(String param, String value) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values=new ContentValues(2);
values.put("key", param);
values.put("value", value);
long result=db.replace("params", null, values);
if (result==-1) Log.e(this.getClass().getCanonicalName(),"Error when updating param "+param+"="+value);
db.close();
getParamValue(param);
}
/**
* Retrieve the value of a param.
*
* @return value of key param
*/
public String getParamValue(String key) {
SQLiteDatabase db = this.getReadableDatabase();
String value;
Cursor cursor = db.query("params", new String[]{"value"}, "key=?", new String[]{key}, null, null, null, null);
if (cursor.getCount() == 0){
value = null;
Log.e(this.getClass().getCanonicalName(), "Error when getting param " + key);
}else {
cursor.moveToFirst();
value = cursor.getString(0);
}
db.close();
return value;
}
/**
* Save the yotta ID of the device, if it is official.
*
* @param serial the official Yotta device ID
*/
public void setSerial(String serial) {
setParam(PARAMS.serial, serial);
}
/**
* Retrieve de serial of the device, if it is registered and official. It returns NULL in other cases.
*
* @return serial the official Yotta device ID or null if it is not specified
*/
public String getSerial() {
return getParamValue(PARAMS.serial);
}
/**
* Save the keyord to escape from the kiosk mode
* @param keyword to chage in DB
*/
public void setKeyword(String keyword) {
setParam(PARAMS.keyword, keyword);
}
/**
* Retrieve the keyword use to escape the kiosk mode
* @author emblanco,fernando
* @return keyword
*/
public String getKeyword() {
return getParamValue(PARAMS.keyword);
}
/**
* Save the device ID, such as the Android ID.
* @param deviceID the platform dependent ID
* @see Device#getDeviceID()
*/
public void setDeviceID(String deviceID) {
setParam(PARAMS.deviceID, deviceID);
}
/**
* @return the platform device ID, such as Android ID, if it is registered, or null if it is not specified.
* @see Device#setDeviceID(String)
*/
public String getDeviceID() {
return getParamValue(PARAMS.deviceID);
}
/**
* Save the id of the student selected
* @param stu_id of the device.
*/
public void setLastStuId(int stu_id) {
setParam(PARAMS.stu_id, String.valueOf(stu_id));
}
/**
* Save the id of the last supervisor
* @param sup_id of the device.
*
*/
public void setLastSupId(int sup_id) {
setParam(PARAMS.sup_id, String.valueOf(sup_id));
}
/**
* Retrieve de last logged user
* @author Miguel Ángel
* @version 1.0
* @return user_id selected or 0.
*/
public int getLastStuId() {
return Integer.valueOf(getParamValue(PARAMS.stu_id));
}
/**
* Retrieve the last supervisor id selected in Login
*
* @return sup_id selected or 0.
*/
public int getLastSupId() {
return Integer.parseInt(getParamValue(PARAMS.sup_id));
}
/**
* @param id_stu
* @param id_sup
* @return the information of an specific user, if they are available in the local DB
* @see Device#getUsers()
*/
public User findUser(int id_stu, int id_sup) throws JSONException {
SQLiteDatabase db = this.getReadableDatabase();
User user = null;
Cursor cursor = db.query("users_detail", null, null, null, null, null, null, null);
while (cursor.moveToNext() && user == null)
if (cursor.getInt(0) == id_stu && cursor.getInt(9) == id_sup)
user = new User(cursor.getInt(0), cursor.getString(1), cursor.getString(2), cursor.getString(3), cursor.getString(4), cursor.getString(5), cursor.getString(6), cursor.getString(7), cursor.getString(8),
cursor.getInt(9), cursor.getString(10), cursor.getString(11), cursor.getString(12), cursor.getString(13), cursor.getString(14), cursor.getString(15), cursor.getString(16), cursor.getString(17));
cursor.close();
db.close();
return user;
}
public Vector<User> recoverStudents(Integer id_sup) throws JSONException{
SQLiteDatabase db = this.getReadableDatabase();
Vector<User> users = new Vector<>();
Cursor cursor = db.query("users_detail", null, null, null, null, null, null, null);
while (cursor.moveToNext())
if (cursor.getInt(9) == id_sup)
users.add(new User(cursor.getInt(0), cursor.getString(1), cursor.getString(2), cursor.getString(3), cursor.getString(4), cursor.getString(5), cursor.getString(6), cursor.getString(7), cursor.getString(8),
cursor.getInt(9), cursor.getString(10), cursor.getString(11), cursor.getString(12), cursor.getString(13), cursor.getString(14), cursor.getString(15), cursor.getString(16), cursor.getString(17)));
cursor.close();
db.close();
return users;
}
/**
* @param auser
* @param apwd
* @return information of a specific user, if it is available in the local DB
*/
public Vector<User> findUser(String auser, String apwd) throws JSONException, LoginException {
SQLiteDatabase db = this.getReadableDatabase();
boolean user_found=false;
Vector<User> users=null;
Cursor cursor = db.query("supervisor", null, null, null, null, null, null, null);
while (cursor.moveToNext() && users == null && !user_found) {
user_found = cursor.getString(1).equalsIgnoreCase(auser);
if (user_found)
if (cursor.getString(2)!=null && cursor.getString(2).equals(apwd)) {
users = recoverStudents(cursor.getInt(0));
if (users.size() == 0)
throw new LoginException("Supervisor hasn't got students", LoginException.NO_STUDENTS);
}
else throw new LoginException("Supervisor password incorrect", LoginException.BAD_LOGIN);
}
cursor.close();
if (!user_found) {
cursor = db.query("student", null, null, null, null, null, null, null);
while (cursor.moveToNext() && users == null && !user_found) {
user_found = cursor.getString(1).equalsIgnoreCase(auser);
if (user_found)
if (cursor.getString(2)!=null && cursor.getString(2).equals(apwd)) {
users = new Vector<>(1);
users.add(new User(cursor.getInt(0), cursor.getString(1), cursor.getString(2), cursor.getString(3), cursor.getString(4), cursor.getString(5), cursor.getString(6), cursor.getString(7), cursor.getString(8),
User.NO_SUPERVISOR, "", "", "", "", "", "", "", ""));
}
else throw new LoginException("Student password incorrect", LoginException.BAD_LOGIN);
}
cursor.close();
}
if (!user_found) throw new LoginException("User not found", LoginException.BAD_LOGIN);
db.close();
return users;
}
/**
* @return a Vector<User> with the whole user who has been registered.
* @see User
* @see com.yottacode.pictogram.dao.PCBDBHelper
*/
public Vector<User> getUsers() throws JSONException {
SQLiteDatabase db = this.getReadableDatabase();
User user;
Cursor cursor = db.query("users_detail", null, null, null, null, null, null, null);
Vector<User> users = new Vector<User>(cursor.getCount());
while (cursor.moveToNext()) {
user = new User(cursor.getInt(0), cursor.getString(1), cursor.getString(2), cursor.getString(3), cursor.getString(4), cursor.getString(5), cursor.getString(6), cursor.getString(7), cursor.getString(8),
cursor.getInt(9), cursor.getString(10), cursor.getString(11), cursor.getString(12), cursor.getString(13), cursor.getString(14), cursor.getString(15), cursor.getString(16), cursor.getString(17));
users.add(user);
}
cursor.close();
db.close();
return users;
}
public void insertUser(User user) {
SQLiteDatabase db = this.getWritableDatabase();
db.execSQL("INSERT INTO users_detail values (" +
user.get_id_stu() + ", " +
"'" + user.get_nickname_stu() + "', " +
(user.get_pwd_stu()==null || user.get_pwd_stu().length()==0 ? "NULL" : "'"+user.get_pwd_stu()+"'") + ", "+
"'" + user.get_name_stu() + "', " +
"'" + user.get_surname_stu() + "', " +
"'" + user.get_url_img_stu() + "', " +
"'" + user.get_gender_stu() + "', " +
"'" + user.get_lang_stu() + "', " +
"'" + user.get_json_attrs() + "', " +
"'" + user.get_id_sup() + "', " +
"'" + user.get_email_sup() + "', " +
"'" + user.get_pwd_sup() + "', " +
"'" + user.get_name_sup() + "', " +
"'" + user.get_surname_sup() + "', " +
"'" + user.get_url_img_sup() + "'," +
"'" + user.get_gender_sup() + "'," +
"'" + user.get_lang_sup() + "'," +
"'" + user.get_tts_engine_sup() + "'" +
")");
db.close();
}
/**
* delete the list of images (students, supervisors, pictograms) which are no longer used
*/
public void deleteDeprecatedImgs() {
SQLiteDatabase db = this.getWritableDatabase();
Cursor cursor = db.query("deprecated_images", null, null, null, null, null, null);
while (cursor.moveToNext()) {
String type = cursor.getString(1);
String folder = type.equals("stu") ? Img.STUDENT : type.equals("sup") ? Img.SUPERVISOR : Img.VOCABULARY;
(new Img(cursor.getInt(0), null, folder)).delete_bitmap(this.context);
Log.i(this.getClass().getCanonicalName(), "Image file " + cursor.getString(1) + "." + cursor.getInt(0) + " deleted");
}
cursor.close();
db.delete("deprecated_images", null, null);
db.close();
}
/**
* Execute the script of the database
* IMPORTANT: every DDL sentence has to finish with the sequence: ;--
*
* @param database picto.db helper
* @param inputStream the stream where the ddl of picto.db is depicted
* @throws IOException
*/
protected static void executeSQLScript(SQLiteDatabase database, InputStream inputStream)
throws IOException {
Vector<String> commands = new Vector<String>(50);
BufferedReader r = new BufferedReader(new InputStreamReader(inputStream));
String command = "";
do {
String line = r.readLine();
if (line == null) break;
if (line.equals(";--")) {
commands.add(command + ";");
command = "";
} else if (!line.startsWith("--")) command += line + " ";
} while (true);
r.close();
for (String sqlStatement : commands)
database.execSQL(sqlStatement);
Log.i(Device.class.getName(), "Database created");
}
/**
* @param url
* @return the local parth where the picto is located or null
*/
public String getPictoPath(String url) {
String path;
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query("picto", new String[]{"path"}, "'url'=?", new String[]{url}, null, null, null, null);
path = cursor.getCount() > 0 ? cursor.getString(0) : null;
cursor.close();
db.close();
return path;
}
/**
* get the next local id for a new local pictogram
*
* @see com.yottacode.pictogram.dao.Picto
*/
public int getNextLocalPictoID() {
SQLiteDatabase db = this.getReadableDatabase();
int next_key;
Cursor cursor = db.query("picto", new String[]{"(SELECT MIN(id) FROM picto) AS MIN"}, null, null, null, null, null, "1");
cursor.moveToFirst();
next_key=cursor.getInt(cursor.getColumnIndex("MIN"))-1;
if (next_key>=0) next_key=-1;
cursor.close();
db.close();
return next_key;
}
@Override
public void onCreate(SQLiteDatabase db) throws RuntimeException {
try {
executeSQLScript(db, DeviceHelper.getDBScriptStream(this.context));
Img.mkDirs(this.context);
copyCoreVocabulary();
} catch (java.io.IOException io) {
throw new RuntimeException("Update database ir cached Images error", io);
}
}
private void copyCoreVocabulary() {
AssetManager assetManager = this.context.getAssets();
String[] files = null;
int size=0;
int filesok=0;
try {
files = assetManager.list(context.getResources().getString(R.string.core_vocabulary));
} catch (IOException e) {
Log.e(this.getClass().getCanonicalName(), "Failed to get asset file list.", e);
}
if (files != null) for (String filename : files) {
InputStream in = null;
OutputStream out = null;
try {
in = assetManager.open(context.getResources().getString(R.string.core_vocabulary)+File.separatorChar+filename);
File outFile = new File(Img.path(this.context, Img.VOCABULARY)+filename);
out = new FileOutputStream(outFile);
size+=copyFile(in, out);
} catch(IOException e) {
Log.e(this.getClass().getCanonicalName(), "Failed to copy asset Image: " + context.getResources().getString(R.string.core_vocabulary)+File.separatorChar+filename, e);
}
finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
Log.e(this.getClass().getCanonicalName(), "Failed to copy asset Image: " + filename, e);
}
}
if (out != null) {
try {
out.close();
filesok++;
} catch (IOException e) {
Log.e(this.getClass().getCanonicalName(), "Failed to copy asset Image: " + filename, e);
}
}
}
}
Log.i(Device.class.getName(), "Core vocabulary Images installed ("+filesok+" pictos,"+(size/1024)+" KB)");
}
private int copyFile(InputStream in, OutputStream out) throws IOException {
byte[] buffer = new byte[8192];
int read;
int size=0;
while((read = in.read(buffer)) != -1){
out.write(buffer, 0, read);
size+=read;
}
return size;
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/dao/LoginException.java deleted 100644 → 0
package com.yottacode.pictogram.dao;
/**
* Created by Fernando on 15/03/2016.
*/
public class LoginException extends Exception{
public static final int BAD_LOGIN=1;
public static final int NO_STUDENTS=2;
public static final int TIME_OUT=3;
int code;
public LoginException(String msg, int code) {
super(msg);
this.code=code;
}
public boolean login_failed() {return this.code==LoginException.BAD_LOGIN;}
public boolean no_supervisor_students() {return this.code==LoginException.NO_STUDENTS;}
public boolean time_out() {return this.code==LoginException.TIME_OUT;}
public String getLocalizedMessage() {
return super.getLocalizedMessage()+" Login ok:"+!login_failed()+" Supervisor without students:"+no_supervisor_students();
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/dao/PCBDBHelper.java deleted 100644 → 0
package com.yottacode.pictogram.dao;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Vector;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.grammar.Vocabulary;
import com.yottacode.pictogram.action.Action;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONException;
import org.json.JSONObject;
/**
* Platform abstraction (Android)
* @see PCBDBHelper
* *
*
* @author Fernando Martinez Santiago
* @version 1.0
*/
class DeviceHelper {
static String getTimestamp() {
return (new android.text.format.Time()).toString();
}
static String getDBName(Context context) {
return context.getResources().getString(R.string.db_name);
}
static InputStream getDBScriptStream(Context context) {
return context.getResources().openRawResource(R.raw.pcbdb_create);
}
static boolean force_create(Context context) {
return context.getResources().getBoolean(R.bool.force_db_create);
}
}
/**
* Data Access Object to manage Pictogram Communicator Board database regarding a logged user
* This class requires:
* The script to create the DB allocated in res/raw/pcbdb_create.sql
* The entries db_name and db_script_error in strings.xml
*
* @author Fernando Martinez Santiago
* @version 1.0
*/
public class PCBDBHelper extends SQLiteOpenHelper {
User currentUser;
boolean user_online; //true if the given user logged into the server
/**
* Create a helper object to create, open, and/or manage a database.
*
* @param factory null
* @param version 1
* @param user the user of the PCB, if any. If not, last user is loaded from the DB
*/
public PCBDBHelper(CursorFactory factory, int version, User user) {
super(PCBcontext.getContext(), DeviceHelper.getDBName(PCBcontext.getContext()), factory, version);
this.user_online=false;
this.setCurrentUser(user == null ? this.getCurrentUser() : user);
}
public boolean isUser_online() {return this.user_online;}
public void user_online(boolean user_online) {this.user_online=user_online;}
/**
* Save the current user of the PCB. It is required to retrieve the last user.
*
* @param user the current PCB user (Student or Supervisor with a given Student collection)
* @see PCBDBHelper#getCurrentUser()
*/
private void setCurrentUser(User user) {
this.currentUser = user;
PCBcontext.getDevice().setLastStuId(user.get_id_stu());
PCBcontext.getDevice().setLastSupId(user.get_id_sup());
}
/**
* @return the last user stored into the DB
* @see PCBDBHelper#getCurrentUser()
*/
public User loadLastUser() {
String stu=String.valueOf(PCBcontext.getDevice().getLastStuId()), sup=String.valueOf(PCBcontext.getDevice().getLastSupId());
User last_user = null;
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query("users_detail", null, "id_stu=? AND id_sup=?", new String[]{stu, sup}, null, null, null, null);
if (cursor.getCount() > 0) {
cursor.moveToFirst();
try {
last_user = new User(cursor.getInt(0), cursor.getString(1), cursor.getString(2), cursor.getString(3), cursor.getString(4), cursor.getString(5), cursor.getString(6), cursor.getString(7), cursor.getString(8),
cursor.getInt(9), cursor.getString(10), cursor.getString(11), cursor.getString(12), cursor.getString(13), cursor.getString(14), cursor.getString(15), cursor.getString(16), cursor.getString(17));
} catch (JSONException e) {
Log.e(this.getClass().getName(), e.getMessage() + " BAD FORMED JSON: " + cursor.getString(5));
System.exit(-1);
}
}
cursor.close();
db.close();
return last_user;
}
/**
* @return the current user who has been logged into the PCB
* @see PCBDBHelper#setCurrentUser(User)
*/
public User getCurrentUser() {
if (this.currentUser == null) this.currentUser = loadLastUser();
return this.currentUser;
}
/**
* Insert a new action
*
* @param action to be inserted
* @see Action
*/
public void insertAction(Action action) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values=new ContentValues(1);
values.put("json_action", action.getDescription().toString());
db.insert("action", null, values);
db.close();
}
/**
* Load saved actions
* @see Action
*/
public Vector<JSONObject> loadActions() {
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query("action", null, null, null, null, null, null, null);
Vector<JSONObject> actions= new Vector(cursor.getCount());
Log.i(this.getClass().getName(), "Local action recovering " + cursor.getCount() + " actions from local DB");
cursor.moveToFirst();
while (cursor.moveToNext())
try {
actions.add(new JSONObject(cursor.getString(0)));
} catch (JSONException e) {
Log.e(this.getClass().getName(), "Recovering batch actions:"+e.getMessage());
}
cursor.close();
db.close();
return actions;
}
/**
* Delete de locally storaged action
* @return the number of deleted rows
*/
public int deleteActions() {
SQLiteDatabase db = this.getWritableDatabase();
return db.delete("action",null,null);
}
/**
* the collection (set of pictos) of the current student
*
* @see com.yottacode.pictogram.dao.Picto
*/
public Vocabulary getStudentVocabulary(Vocabulary vocabulary ) throws JSONException {
int id_stu = this.getCurrentUser().get_id_stu();
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query("collection_detail", null, "id_stu=?", new String[]{String.valueOf(id_stu)}, null, null, null, null);
Log.i(this.getClass().getName(), "Local recovering " + cursor.getCount() + " pictos for student " + id_stu + " from local DB");
cursor.moveToFirst();
while (cursor.moveToNext()) {
Picto picto = new Picto(cursor.getInt(1), cursor.getString(2), cursor.getString(3), cursor.getString(4));
vocabulary.loadPicto(picto);
}
cursor.close();
db.close();
return vocabulary;
}
/**
* Set/update the set of pictos of the current student. Pictos which are no longer used are dropped from the DB
*
* @param vocabulary the vocabulary, the configuration of the Student
* @see com.yottacode.pictogram.dao.Picto
*/
public void setStudentVocabulary(Vocabulary vocabulary) {
SQLiteDatabase db = this.getWritableDatabase();
int id_stu = this.getCurrentUser().get_id_stu();
int seconds1 = Calendar.getInstance().get(Calendar.SECOND);
db.delete("collection", "id_stu=" + id_stu, null);
int newsize=0;
ContentValues values=new ContentValues(5);
values.put("id_stu", id_stu);
for (Picto picto : vocabulary) {
newsize++;
values.put("id_picto", picto.get_id());
values.put("url", picto.get_url());
values.put("translation",picto.get_translation());
values.put("attributes",picto.get_json_attrs());
db.insert("collection_detail", null, values);
}
int seconds2 = Calendar.getInstance().get(Calendar.SECOND);
Log.i(this.getClass().getName(), " Local student vocabulary updated, id:" + id_stu + ", cats: " + vocabulary.size() + " time:" + (seconds2 - seconds1) + " secs. Size: " + newsize + " read only?" + db.isReadOnly());
db.close();
}
/**
* Insert/update a picto of the current student.
*
* @param picto added to the Student collection
* @see com.yottacode.pictogram.dao.Picto
*/
public void addPicto(Picto picto) {
int id_stu = this.getCurrentUser().get_id_stu();
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values=new ContentValues(6);
values.put("id_stu", id_stu);
values.put("id_picto", picto.get_id());
values.put("url", picto.get_url());
values.put("translation",picto.get_translation());
values.put("attributes",picto.get_json_attrs());
db.insert("collection_detail", null, values);
db.close();
}
/**
* Delete a picto of the current collection's student. Pictos which are no longer used are dropped from the DB
*
* @param picto_id to be deleted from the configuration of the Student
* @see com.yottacode.pictogram.dao.Picto
*/
public void deletePicto(int picto_id) {
int id_stu = this.getCurrentUser().get_id_stu();
SQLiteDatabase db = this.getWritableDatabase();
db.delete("collection","id_stu=? AND id_picto=?",
new String[]{ Integer.toString(this.currentUser.get_id_stu()),
Integer.toString(picto_id)});
db.close();
}
/**
* Update a picto of the current collection's student.
*
* @param picto_id to be modified from the configuration of the Student
* @param attrs new picto attributes
* @see com.yottacode.pictogram.dao.Picto
*/
public void modifyPicto(int picto_id, String attrs) {
int id_stu = this.getCurrentUser().get_id_stu();
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues(1);
values.put("attributes",attrs);
int updates=db.update("collection",values, "id_stu=? AND id_picto=?", new String[] {Integer.toString(id_stu), Integer.toString(picto_id)});
Log.i(this.getClass().getCanonicalName(),"Modify "+updates+" Picto, id. "+picto_id+" attributes="+attrs);//+ "::"+ Arrays.toString(Thread.currentThread().getStackTrace()));
db.close();
}
@Override
public void onCreate(SQLiteDatabase db) throws RuntimeException {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/dao/Picto.java deleted 100644 → 0
package com.yottacode.pictogram.dao;
import android.graphics.Color;
import android.util.Log;
import com.yottacode.pictogram.action.VocabularyAction;
import com.yottacode.pictogram.net.PictoUploader;
import com.yottacode.pictogram.tools.Img;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.Serializable;
/**
* A object which represents a pictogram
* *
* @author Fernando Martinez Santiago
* @version 1.0
*/
public class Picto extends Img {
// String constant for logs
private final String LOG_TAG = this.getClass().getSimpleName(); // Or .getCanonicalName()
public final static class JSON_ATTTRS {
public static String CATEGORY = "id_cat";
public static String COLUMN = "coord_x";
public static String ROW = "coord_y";
public static String FREE_COLUMN = "free_category_coord_x";
public static String FREE_ROW = "free_category_coord_y";
public static String MAGNIFY = "magnify";
public static String HIGHLIGHT = "highlight";
public static String STATUS = "status";
public static String COLOR = "color";
public static String PCB_STATUS_MODIFICATION="pcb_status_modification";
}
public final static class JSON_ATTTR_STATUS_VALUES {
static String ENABLED = "enabled";
static String DISABLED = "disabled";
static String INVISIBLE = "invisible";
}
public final static int NO_CATEGORY=-1;
public final static int ROW_UNCATEGORIZED_CONCEPTS=0;
private JSONObject attributes;
private String translation;
public Picto(int id, String url, String translation, int cat, int row, int column, int freeRow, int freeColumn) throws JSONException {
this(id, url, translation, new JSONObject()
.put(JSON_ATTTRS.CATEGORY, cat)
.put(JSON_ATTTRS.COLUMN, column)
.put(JSON_ATTTRS.ROW, row)
.put(JSON_ATTTRS.FREE_ROW, freeRow)
.put(JSON_ATTTRS.FREE_COLUMN, freeColumn)
.put(JSON_ATTTRS.STATUS, JSON_ATTTR_STATUS_VALUES.ENABLED));
}
public Picto(int id, String url,String translation, String attributes) throws JSONException {
this(id, url, translation, new JSONObject(attributes));
}
public Picto(int id, String url,String translation, JSONObject attributes) {
super(id,url,Img.VOCABULARY);
this.translation=translation;
this.attributes = attributes;
try {
if (this.attributes.get(JSON_ATTTRS.CATEGORY)==null)
this.attributes.put(JSON_ATTTRS.CATEGORY, Picto.NO_CATEGORY);
} catch (JSONException e) {
Log.e(this.getClass().getName(), e.toString());
}
}
/**
*
* @return true if it's a local pictogram
*/
public boolean is_local() {return this.get_id()<0;}
/**
*
* @return de id of the picto
*/
public int get_id() {return this.id;}
public void update_id(int id) {
this.id = id;
}
/**
*
* @return the location of the picto
*/
public String get_url() {return this.url;}
/**
*
* @return the translation of the picto to a given language
*/
public String get_translation() {return this.translation;}
/**
*
* @return a JSON attributes of the picto
*/
public String get_json_attrs() {
return this.attributes.toString();
}
/**
* JSON attrs of the picto except the param regarding is locally modified since this is not saved into the server
*
*
*/
public String get_json_server_attrs() {
JSONObject json = null;
try {
json = new JSONObject(this.attributes.toString());
} catch (JSONException e) {
e.printStackTrace();
}
json.remove(JSON_ATTTRS.PCB_STATUS_MODIFICATION);
return json.toString();
}
/**
* Set JSON attribute of the picto
* @param attr attributes modified
*/
public void set_json_attr(JSONObject attr) {
this.attributes=attr;
}
/**
*
* @return the category of the picto
*/
public int get_category() {
try {
return this.attributes.getInt(JSON_ATTTRS.CATEGORY);
} catch (JSONException e) {
return Picto.NO_CATEGORY;
}
}
/**
*
* @return the magnifiy property of a picto
*/
public boolean is_magnify() {
try {
return Boolean.parseBoolean(this.attributes.getString(JSON_ATTTRS.MAGNIFY));
} catch (JSONException e) {
return false;
}
}
/**
*
* @return if the picto is enabled
*/
public boolean is_enabled() {
try {
return this.attributes.getString(JSON_ATTTRS.STATUS).equals(JSON_ATTTR_STATUS_VALUES.ENABLED);
} catch (JSONException e) {
return false;
}
}
/**
*
* @return if the picto is disabled
*/
public boolean is_disabled() {
try {
return this.attributes.getString(JSON_ATTTRS.STATUS).equals(JSON_ATTTR_STATUS_VALUES.DISABLED);
} catch (JSONException e) {
return false;
}
}
/**
*
* @return if the picto is visible
*/
public boolean is_invisible() {
try {
return this.attributes.getString(JSON_ATTTRS.STATUS).equals(JSON_ATTTR_STATUS_VALUES.INVISIBLE) ||
(this.is_category() && !PCBcontext.getVocabulary().isVisibleCategory(this.get_id()));
} catch (JSONException e) {
return false;
}
}
/**
*
* @return the highlight property of a picto
*/
public boolean is_highlight() {
try {
return Boolean.parseBoolean(this.attributes.getString(JSON_ATTTRS.HIGHLIGHT));
} catch (JSONException e) {
return false;
}
}
/**
*
* @return the status of a picto (enabled | disabled | invisible)
*/
public String get_status() {
try {
return this.attributes.getString(JSON_ATTTRS.STATUS);
} catch (JSONException e) {
return "enabled"; // By default
}
}
/**
*
* @return the row of the picto
*/
public int get_row() {
return this.attributes.optInt(JSON_ATTTRS.ROW, -1);
}
/**
*
* @return the column of the picto
*/
public int get_column() {
return this.attributes.optInt(JSON_ATTTRS.COLUMN, -1);
}
/**
*
* @return the free row of the picto
*/
public int getFreeRow() {
return this.attributes.optInt(JSON_ATTTRS.FREE_ROW, -1);
}
/**
*
* @return the free column of the picto
*/
public int getFreeColumn() {
return this.attributes.optInt(JSON_ATTTRS.FREE_COLUMN, -1);
}
/**
*
* @return the color of the picto
*/
public int get_color() {
try {
String color = this.attributes.getString(JSON_ATTTRS.COLOR);
int icolor = Color.parseColor(color);
return icolor;
} catch (JSONException e) {
return -1;
}
}
/**
*
* @return the lighter color of the picto
*/
public int get_lighter_color() {
final int LIGHT=0x22;
int color = this.get_color();
int red = Color.red(color)+LIGHT, blue = Color.blue(color)+LIGHT, green = Color.green(color)+LIGHT;
return Color.rgb(red, green, blue);
}
/**
*
* @return the darkner color of the picto
*/
public int get_darkner_color() {
/*
final int DARK=-0x22;
int color = this.get_color();
int red = Color.red(color)+DARK, blue = Color.blue(color)+DARK, green = Color.green(color)+DARK;
return Color.rgb(red,green,blue);
*/
/*
String hexColor = String.format("#%06X", (0xFFFFFF & this.get_color()));
String hexColorDarker = String.format("#%06X", (0xFFFFFF & darker(this.get_color(), (float)0.9)));
Log.d(LOG_TAG, "Color actual: " + hexColor);
Log.d(LOG_TAG, "Color darker: " + hexColorDarker);
*/
return darker(this.get_color(), (float) 0.9);
}
public static int darker (int color, float factor) {
int a = Color.alpha(color);
int r = Color.red(color);
int g = Color.green(color);
int b = Color.blue(color);
return Color.argb(a,
Math.max((int) (r * factor), 0),
Math.max((int) (g * factor), 0),
Math.max((int) (b * factor), 0));
}
/**
* A picto is a category iif:
* (i) it has not got category
* (ii) it is not an uncategorized concept (such as "yes","no","thank you")
* @return
*/
public boolean is_category() {
return this.get_category()==Picto.NO_CATEGORY &&
this.get_column() != Picto.ROW_UNCATEGORIZED_CONCEPTS &&
this.getFreeColumn() == -1 &&
this.getFreeRow() == -1;
}
/**
*
* @overide
* Two user are equals whenever they have the same id
*/
public boolean equals(Object o) {
return ((Picto)o).id==this.id;
}
/**
* toString method
*/
public String toString(){
return "(" + get_id() + ") - ["+ get_row() +","+ get_column()+"]" + get_translation() + "(Cat: " + get_category() + ") - " + get_url() + " --- " + get_json_attrs();
}
/**
* modify locally the status of the picto
* @return true if current status is enabled. False in other case.
*/
public boolean alter_status() {
String status=is_enabled() ? JSON_ATTTR_STATUS_VALUES.DISABLED : JSON_ATTTR_STATUS_VALUES.ENABLED;
Log.i(this.getClass().getCanonicalName(),"Picto id. "+get_id()+" status enabled/disabled modified to "+is_enabled());
try {
this.attributes.put(JSON_ATTTRS.STATUS, status);
set_local_status(true);
if (!is_local()) {
new PictoUploader(this).uploadState();
PCBcontext.getActionLog().log(new VocabularyAction(VocabularyAction.ALTERATTRS, this));
}
} catch (JSONException e) {
e.printStackTrace();
Log.e(this.getClass().getCanonicalName(),e.getMessage());
}
return is_enabled();
}
/**
*
* @return true if the status of picto was modified from the PCB
*/
public boolean local_status() {
return !this.attributes.isNull(JSON_ATTTRS.PCB_STATUS_MODIFICATION);
}
/**
* when the status is locally modified, it is required to remove when it is uploaded since it is no longer a local modification
*/
public void set_local_status(boolean local) {
if (local)
try {
this.attributes.put(JSON_ATTTRS.PCB_STATUS_MODIFICATION, true);
PCBcontext.getPcbdb().modifyPicto(this.get_id(), this.get_json_attrs());
} catch (JSONException e) {
e.printStackTrace();
Log.e(this.getClass().getCanonicalName(), e.getMessage());
}
else {
this.attributes.remove(JSON_ATTTRS.PCB_STATUS_MODIFICATION);
PCBcontext.getPcbdb().modifyPicto(this.get_id(), this.get_json_attrs());
}
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/dao/User.java deleted 100644 → 0
package com.yottacode.pictogram.dao;
import java.io.IOException;
import org.json.JSONObject;
import org.json.JSONException;
import android.content.Context;
import android.graphics.Bitmap;
import com.yottacode.pictogram.tools.Img;
import com.yottacode.pictogram.grammar.Vocabulary;
/**
* A user of the PCB. A user can be an Student or a Supervisor using a student configuration
* *
* @author Fernando Martinez Santiago
* @version 1.1
*/
public class User {
public static final int NO_SUPERVISOR = -1;
public boolean has_supervisor() {
return this.get_id_sup()!=User.NO_SUPERVISOR;
}
public final static class JSON_STUDENT_ATTTRS{
static String CATEGORIES = "categories";
static String INPUT_FEEDBACK = "input feedback";
static String INPUT_SELECTION = "input selection";
static String PICTOGRAM_SIZE = "pictogram size";
static String TTS_ENGINE = "tts engine";
static String TTS_VOICE = "tts voice";
}
private Img img_stu;
private String nickname_stu, pwd_stu, name_stu, surname_stu, gender_stu, lang_stu;
private JSONObject attributes_stu;
private Img img_sup;
private String email_sup, pwd_sup, name_sup, surname_sup, gender_sup, lang_sup, tts_engine_sup;
public User(int id_stu, String nickname_stu, String pwd_stu, String name_stu, String surname_stu, String url_img_stu, String gender_stu, String lang_stu, String attributes_stu) throws JSONException {
this(id_stu, nickname_stu, pwd_stu, name_stu, surname_stu, url_img_stu, gender_stu, lang_stu, attributes_stu,User.NO_SUPERVISOR,"","","","","","M","es-es",null);
}
public User(int id_stu, String nickname_stu, String pwd_stu, String name_stu, String surname_stu, String url_img_stu, String gender_stu, String lang_stu, String attributes_stu,
int id_sup, String email_sup, String pwd_sup, String name_sup, String surname_sup, String url_img_sup, String gender_sup, String lang_sup, String tts_engine_sup) throws JSONException {
this.img_stu=new Img(id_stu,url_img_stu,Img.STUDENT);
this.nickname_stu=nickname_stu;
this.pwd_stu=pwd_stu;
this.name_stu=name_stu;
this.surname_stu=surname_stu;
this.gender_stu=gender_stu;
this.lang_stu=lang_stu;
this.attributes_stu= attributes_stu!=null && attributes_stu.trim().length()>0 ? new JSONObject(attributes_stu) : new JSONObject();
this.img_sup=new Img(id_sup,url_img_sup,Img.SUPERVISOR);
this.email_sup=email_sup;
this.pwd_sup=pwd_sup;
this.name_sup=name_sup;
this.surname_sup=surname_sup;
this.gender_sup=gender_sup;
this.lang_sup=lang_sup;
this.tts_engine_sup=tts_engine_sup;
}
/**
*
* @return id of the student
*/
public int get_id_stu() {return this.img_stu.get_id();}
/**
*
* @return nickname (username) of the student
*/
public String get_nickname_stu() {return this.nickname_stu;}
/**
*
* @return pwd of the student
*/
public String get_pwd_stu() {return this.pwd_stu;}
/**
* @ return the RESTAPI operator for the current student
*/
public String get_restapi_operation_stu() {
return "stu/"+this.get_id_stu();
}
/**
*
* @return Img of the student
*/
public Img get_img_stu() {return this.img_stu;}
/**
*
* @return name of the student
*/
public String get_name_stu() {return this.name_stu;}
/**
*
* @return surname of the student
*/
public String get_surname_stu() {return this.surname_stu;}
/**
*
* @return url of the picture of the student profile
*/
public String get_url_img_stu() {return this.img_stu.get_url();}
/**
*
* @return Img of the student
*/
public Bitmap get_bitmap_stu(Context context) throws IOException {return this.img_stu.get_bitmap(context);}
/**
*
* @return Img of the student
*/
public Img get_Img_stu() {return this.img_stu;}
/**
*
* @return gender of the student
*/
public String get_gender_stu() {return this.gender_stu;}
/**
*
* @return language of the student
*/
public String get_lang_stu() {return this.lang_stu;}
/**
*
* @return id of the supervisor
*/
public int get_id_sup() {return this.img_sup.get_id();}
/**
*
* @return nickname (username) of the student
*/
public String get_email_sup() {return this.email_sup;}
/**
*
* @return pwd of the student
*/
public String get_pwd_sup() {return this.pwd_sup;}
/**
*
* @return name of the supervisor
*/
public String get_name_sup() {return this.name_sup;}
/**
*
* @return surname of the supervisor
*/
public String get_surname_sup() {return this.surname_sup;}
/**
*
* @return url of image of the supervisor profile
*/
public String get_url_img_sup() {return this.img_sup.get_url();}
/**
*
* @return Bitmap of the supervisor
*/
public Bitmap get_bitmap_sup(Context context) throws IOException {return this.img_sup.get_bitmap(context);}
/**
*
* @return Img of the supervisor
*/
public Img get_Img_sup() {return this.img_sup;}
/**
*
* @return gender of the supervisor
*/
public String get_gender_sup() {return this.gender_sup;}
/**
*
* @return language of the supervisor
*/
public String get_lang_sup() {return this.lang_sup;}
/**
*
* @return TTS engine of the supervisor
*/
public String get_tts_engine_sup() {return this.tts_engine_sup;}
/**
*
* @return a JSON attributes of the user
*/
public String get_json_attrs() {
return this.attributes_stu.toString();
}
/**
*
* @return a JSON attribute of the student or NULL if the given attribute is not available
*/
public String get_json_attr(String attr) {
try {
return this.attributes_stu.getString(attr);
} catch (JSONException e) {
return null;
}
}
/**
*
* @return true if the collection is organized by categories (default: True)
*/
public boolean has_categories() {
return this.attributes_stu.optBoolean(JSON_STUDENT_ATTTRS.CATEGORIES, true);
}
/**
*
* @return input feedback of the student configuration (default: "vibration")
*/
public String get_input_feedback() {
try {
return this.attributes_stu.getString(JSON_STUDENT_ATTTRS.INPUT_FEEDBACK);
} catch (JSONException e) {
return "vibration";
}
}
/**
*
* @return input selection of the student configuration (default: "click")
*/
public String get_input_selection() {
try {
return this.attributes_stu.getString(JSON_STUDENT_ATTTRS.INPUT_SELECTION);
} catch (JSONException e) {
return "click";
}
}
/**
*
* @return pictogram size of the student configuration (default: "normal")
*/
public String get_pictogram_size() {
try {
return this.attributes_stu.getString(JSON_STUDENT_ATTTRS.PICTOGRAM_SIZE);
} catch (JSONException e) {
return "normal";
}
}
public boolean is_supervisor() {
return get_id_sup()!=User.NO_SUPERVISOR;
}
/**
*
* @overide
* Two user are equals whenever they have the same student and supervisor id
*/
public boolean equals(Object o) {
return ((User)o).img_stu.get_id()==this.img_stu.get_id() && ((User)o).img_sup.get_id()==this.img_sup.get_id();
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/grammar/Vocabulary.java deleted 100644 → 0
package com.yottacode.pictogram.grammar;
import android.os.AsyncTask;
import android.util.Log;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.action.VocabularyAction;
import com.yottacode.pictogram.dao.PCBDBHelper;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.net.ImgDownloader;
import com.yottacode.pictogram.net.PictoUploader;
import com.yottacode.pictogram.tools.Img;
import com.yottacode.net.iRestapiListener;
import com.yottacode.pictogram.action.Room;
import com.yottacode.pictogram.net.iImgDownloaderListener;
import com.yottacode.pictogram.tools.PCBcontext;
import com.yottacode.tools.GUITools;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;
import java.util.Vector;
/**
* PCB Vocabulary manager
* @author Fernando Martinez Santiago
* @version 1.0
*/
public class Vocabulary implements Iterable<Picto> {
Hashtable<Integer,LinkedList<Picto>> pictos;
static int DEFAULT_VOCABULARY_SIZE=200;
VocabularyTalk talk;
iImgDownloaderListener imgListener;
/**
* Creates a new vocabulary and download/load the vocabulary and the corresponding pictos
* @param listener
*/
public Vocabulary(iImgDownloaderListener listener) {
this.pictos = new Hashtable<>(Vocabulary.DEFAULT_VOCABULARY_SIZE);
this.imgListener=listener;
if (PCBcontext.getNetService().online()) {
synchronize();
}else
try {
PCBcontext.getPcbdb().getStudentVocabulary(this);
if (listener!=null)
listener.loadComplete();
} catch (JSONException e) {
Log.e(this.getClass().getName(),"Local vocabulary recover failed: "+e.getMessage());
listener.error(e);
}
}
public void listen(Room room, iVocabularyListener listener) {
iVocabularyListener listeners[] = {new iVocabularyListener() {
@Override
public void change(action action, int picto_cat, int picto_id, JSONObject args) {
switch (action) {
case delete: {
removePicto(picto_cat, picto_id);
break;
}
case update:{
Log.i(this.getClass().getCanonicalName(), "Picto update "+args.toString());
try {
modifyAttsPicto(picto_cat, picto_id, args.getJSONObject("attributes"));
} catch (JSONException e) {
e.printStackTrace();
}
break;
}
case add:{
try{
String text= args.getJSONObject("expression").getString("text");
String uri=args.getJSONObject("picto").getString("uri");
JSONObject attrs_picto = args.getJSONObject("attributes");
addPicto(new Picto(picto_id, uri, text, attrs_picto),ImgDownloader.tsource.remote);
} catch (JSONException e) {
Log.e(this.getClass().getCanonicalName(), e.getClass().getCanonicalName() + "--" + e);
// System.exit(-1);
}
break;
}
}
}
},listener};
talk = new VocabularyTalk(room, listeners);
}
/**
* UPload local status modifications and new pictos. Note that when
* a picto is uploaded is not required to delete from the local PCB
* because the PCB will get the remote vocabulary at the end of the process
* The only issue is: what happens whether the upload fails? --> The image will be lost.
* TODO: keep record of failed uploaded images to re-include as local pictos
*/
private void synchronize_upload() {
try {
PCBcontext.getPcbdb().getStudentVocabulary(this);
} catch (JSONException e) {
Log.e(this.getClass().getName(), " Picto json error from local storage: " + e.getMessage());
}
for (Picto picto: this) {
if (picto.local_status()) {
new PictoUploader(picto).uploadState();
Log.i(this.getClass().getCanonicalName(), "Picto status modified while offline. Picto translation: '" +
picto.get_translation() + "', id:" + picto.get_id() + " Local status?" + picto.local_status());
}
if (picto.is_local()) //id<0 iif it is a local id
try {
Log.i(this.getClass().getCanonicalName(), "Picto added while offline. Picto translation: '" +
picto.get_translation() + "', id:" + picto.get_id() + " Local status?" + picto.local_status());
new PictoUploader(picto).upload(PCBcontext.getContext());
} catch (IOException e) {
e.printStackTrace();
Log.e(this.getClass().getName(), " Picto json error from server: " + picto.toString());
}
}
}
/**
* the vocabulary is (i) updated to and (ii) downloaded from the server.
*/
public void synchronize() {
synchronize_upload();
//download
final String picto_str="/pictos";
String operation=PCBcontext.getPcbdb().getCurrentUser().get_restapi_operation_stu()+picto_str;
PCBcontext.getRestapiWrapper().ask(operation, new iRestapiListener() {
@Override
public void preExecute() {
}
@Override
public void result(JSONArray result) {
if (result != null) {
final String jpicto = "picto";
final String jid = "id";
final String juri = "uri";
final String jattributes = "attributes";
final String jexpression = "expression";
final String jexpression_text = "text";
Picto[] pictos = new Picto[result.length()];
JSONObject picto = null, expression = null, attributes = null;
JSONObject ojpicto=null;
try {
for (int i=0; i < result.length(); i++) {
ojpicto=result.getJSONObject(i);
picto = ojpicto.getJSONObject(jpicto);
expression = ojpicto.getJSONObject(jexpression);
attributes = ojpicto.getJSONObject(jattributes);
pictos[i] = new Picto(picto.getInt(jid),
picto.getString(juri),
expression.getString(jexpression_text),
attributes);
}
synchronizeImgs(pictos);
PCBcontext.getPcbdb().setStudentVocabulary(Vocabulary.this);
Log.i(this.getClass().getName(), " Pictos downloaded: " + result.length());
} catch (JSONException e) {
StackTraceElement traces[] = e.getStackTrace();
for (StackTraceElement s: traces)
Log.e(s.getClassName()+"."+s.getFileName()+"."+s.getLineNumber(),s.toString());
Log.e(this.getClass().getName(), " Picto JSON error from server: " + ojpicto.toString());
this.error(e);
}
}
}
@Override
public void result(JSONObject result) {
}
@Override
public void error(Exception e) {
Log.e(this.getClass().getName(), " Server RESTAPI error: " + e.getLocalizedMessage());
Vocabulary.this.imgListener.error(e);
}
});
}
/**
* synchronize the local collection with the downloaded remote collection
*
* @param updated_collection is the downloaded remote collection
* @throws JSONException in case of user.attributes json parsing error
*/
private void synchronizeImgs(Picto updated_collection[]) throws JSONException {
Vector<Img> imgs=new Vector<Img>(updated_collection.length);
this.pictos.clear();
for (Picto updated_picto: updated_collection) {
LinkedList<Picto> pictos_cat;
Picto picto = new Picto(updated_picto.get_id(),
updated_picto.get_url(),
updated_picto.get_translation(),
updated_picto.get_json_attrs());
if (pictos.containsKey(picto.get_category()))
pictos_cat = pictos.get(picto.get_category());
else {
pictos_cat = new LinkedList<>();
pictos.put(new Integer(picto.get_category()),pictos_cat);
}
pictos_cat.add(picto);
imgs.add(new Img(picto.get_id(), picto.get_url(), Img.VOCABULARY));
}
Log.d(this.getClass().getName(), "Vocabulary size: " + updated_collection.length);
ImgDownloader downloader = new ImgDownloader(PCBcontext.getContext(), imgListener,ImgDownloader.tsource.remote);
downloader.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, imgs);
}
public int size() { return this.pictos.size();}
/**
* It includes/updates a new picto to the user collection: download the image from remote or local storage, add the picto to the current vocabulary and update the database
* @param pic
*/
public void addPicto(Picto pic, ImgDownloader.tsource source){
addPicto(pic, source, this.imgListener);
}
public void addPicto(Picto pic, ImgDownloader.tsource source, iImgDownloaderListener imgListener){
Vector<Img> imgs=new Vector<Img>(1);
imgs.add(new Img(pic.get_id(), pic.get_url(), Img.VOCABULARY));
ImgDownloader downloader = new ImgDownloader(PCBcontext.getContext(), imgListener,source);
downloader.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, imgs);
loadPicto(pic);
PCBcontext.getPcbdb().addPicto(pic);
}
/**
*
* @param pic_cat
* @return
*/
private boolean empty_category(int pic_cat) {return this.pictos.get(pic_cat)==null;}
private int find_picto_index(int pic_cat, int pic_id) {
LinkedList<Picto> pictos_cat=this.pictos.get(pic_cat);
int index=-1;
for (int i=0; i<pictos_cat.size() && index==-1; i++)
if (pictos_cat.get(i).get_id()==pic_id) index=i;
return index;
}
/**
* It removes de given pic from the user collection
* @param pic_id
*/
public void removePicto(int pic_cat, int pic_id){
LinkedList<Picto> pictos_cat=this.pictos.get(pic_cat);
int index = find_picto_index(pic_cat, pic_id);
if (index>=0) { //puede ocurrir que se intente borrar un pictograma dos veces
pictos_cat.remove(index);
PCBcontext.getPcbdb().deletePicto(pic_id);
}
else
Log.i(this.getClass().getCanonicalName(),"Trying to delete an unregistered picto:"+pic_id+" cat:"+pic_cat);
}
/**
* It modifies de given pic from the user collection
* @param pic_cat
* @param pic_id
* @param attrs
*/
public void modifyAttsPicto(int pic_cat, int pic_id, JSONObject attrs) {
int index=find_picto_index(pic_cat, pic_id);
if (index>=0) { //puede ocurrir que se intente modificar un pictograma que fue borrado
Picto picto = this.pictos.get(pic_cat).get(index);
picto.set_json_attr(attrs);
PCBcontext.getPcbdb().modifyPicto(pic_id, attrs.toString());
}
else
Log.i(this.getClass().getCanonicalName(),"Trying to modify an unregistered picto:"+pic_id+" cat:"+pic_cat);
}
/**
* It loads into the vocabulary a given picto which was stored in the local db.
* This method is called by the PCDBHelper when the collection is loaded
* @param picto
* @seealso com.yottacode.pictogram.dao.PCBDBHelper.getStudentVocabulary
*/
public void loadPicto(Picto picto) {
LinkedList<Picto> pictos_cat;
if (this.pictos.containsKey(picto.get_category()))
pictos_cat = pictos.get(picto.get_category());
else {
pictos_cat = new LinkedList();
this.pictos.put(new Integer(picto.get_category()),pictos_cat);
}
pictos_cat.add(picto);
}
/**
*
* @return list of pictos which should be selectable at the beginning of a sentence. Empty categories are removed
*/
public LinkedList<Picto> startSentence(){
if (PCBcontext.getPcbdb().getCurrentUser().has_categories()) {
return this.pictos.get(new Integer(Picto.NO_CATEGORY));
} else {
LinkedList<Picto> freePictos = new LinkedList<>();
for (LinkedList<Picto> category : pictos.values()) {
for (Picto picto : category) {
if (picto.getFreeRow() != -1 && picto.getFreeColumn() != -1) {
freePictos.add(picto);
}
}
}
return freePictos;
}
}
/**
* A category is visible iif it has at least an enabled concept
* @param id
* @return
*/
public boolean isVisibleCategory(int id) {
if (empty_category(id)) return false;
if (PCBcontext.getPcbdb().getCurrentUser().is_supervisor()) return true;
boolean visible=false;
for (Picto picto : this.pictos.get(id)) {
visible=!picto.is_invisible();
if (visible) break;
}
return visible;
}
/*
* It saves locally a new picto obtained from the PCB
*/
public Picto saveLocalPicto(String url, String exp, int cat, int coord_x, int coord_y, int free_category_coord_x, int free_category_coord_y, final iLocalPicto listener) {
int id= PCBcontext.getDevice().getNextLocalPictoID();
final Picto picto[]=new Picto[1];
try {
picto[0] = new Picto(id, url, exp, cat, coord_x, coord_y, free_category_coord_x, free_category_coord_y);
addPicto(picto[0], ImgDownloader.tsource.local, new iImgDownloaderListener() {
@Override
public void loadComplete() {
listener.saved(picto[0]);
}
@Override
public void loadImg(Img image) {
}
@Override
public void error(Exception e) {
GUITools.show_alert(PCBcontext.getContext(), R.string.serverError, e.getMessage());
Log.e(this.getClass().getCanonicalName(), "Server error:"+ e.getLocalizedMessage());
}
});
} catch (Exception e) {
picto[0]=null;
e.printStackTrace();
Log.e(Vocabulary.class.getCanonicalName(), e.getMessage());
}
PCBcontext.getActionLog().log(new VocabularyAction(VocabularyAction.ADD, picto[0]));
return picto[0];
}
/**
*
* @param picto
* @return set of pictos which should be selectable in a given sentence state
*/
public LinkedList<Picto> next(Picto picto){
return picto.is_category() ? this.pictos.get(picto.get_id()) : startSentence() ;
}
@Override
public Iterator<Picto> iterator() {
return new VocabularyIterator(this.pictos);
}
@Override
public String toString() {
String vocabulary = "{";
Set<Integer> cats = this.pictos.keySet();
for (Integer cat : cats) {
vocabulary += "{\"id category\" : \"" + cat + "\", \"picto\": [";
int i = 0;
for (Picto picto : this.pictos.get(cat)) {
i++;
vocabulary += "{\"id\" : \"" + picto.get_id() + "\"" + ", \"translation\" : \"" + picto.get_translation() + "\"}";
if (i < this.pictos.size()) vocabulary += ", ";
}
vocabulary += "]";
}
vocabulary += "}";
return vocabulary;
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/grammar/VocabularyIterator.java deleted 100644 → 0
package com.yottacode.pictogram.grammar;
import android.util.Log;
import com.yottacode.pictogram.dao.Picto;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
/**
* PCB Vocabulary manager
* @author Fernando Martinez Santiago
* @version 1.0
*/
public class VocabularyIterator implements Iterator<Picto> {
Enumeration<Integer> keys;
Hashtable<Integer,LinkedList<Picto>> pictos;
Integer category;
int location;
VocabularyIterator(Hashtable<Integer,LinkedList<Picto>> pictos) {
this.keys = pictos.keys();
if (pictos.size()>1) {
this.pictos=pictos;
this.category = this.keys.nextElement();
}
else {
this.category=-1;
this.pictos=new Hashtable<>(1);
this.pictos.put(this.category, new LinkedList<Picto>());
}
this.location=0;
}
@Override
public boolean hasNext() {
return this.location<pictos.get(category).size() || keys.hasMoreElements();
}
@Override
public Picto next() {
Picto picto;
if ( this.location==pictos.get(category).size()) {
this.location = 0;
this.category = this.keys.nextElement();
}
picto=pictos.get(category).get(location++);
return picto;
}
@Override
public void remove() {
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/grammar/VocabularyTalk.java deleted 100644 → 0
package com.yottacode.pictogram.grammar; import android.util.Log; import com.github.nkzawa.emitter.Emitter; import org.json.JSONException;import org.json.JSONObject; import com.yottacode.pictogram.dao.Picto;import com.yottacode.pictogram.action.Room; /** * Websocket Vocabulary Room based on Room * @author Fernando Martinez Santiago * @version 1.0 */public class VocabularyTalk implements Emitter.Listener { private static final String URL ="vocabulary"; private Room room; iVocabularyListener listeners[]; public VocabularyTalk(Room room, iVocabularyListener listeners[]) { this.room = room; this.room.listen(URL, this); this.listeners=listeners; } @Override public void call(Object... args) { final String param_action="action"; final String param_attributes="attributes"; final String param_picto="picto"; final String param_stu_picto="stu_picto"; final String param_picto_id="id"; final String param_picto_cat="id_cat"; final String action_update="update"; final String action_add="add"; final String action_delete="delete"; JSONObject msg = (JSONObject) args[0]; try { Log.i(this.getClass().getName(), "raw Received message " +msg.toString()); String action = msg.getString(param_action).toLowerCase(); JSONObject stu_picto= msg.getJSONObject(param_attributes).getJSONObject(param_stu_picto); JSONObject attrs_stu_picto = stu_picto.optJSONObject(param_attributes); JSONObject attrs_picto = stu_picto.optJSONObject(param_picto); int picto_id = attrs_picto.getInt(param_picto_id); int picto_cat = attrs_stu_picto!=null ? attrs_stu_picto.optInt(param_picto_cat, Picto.NO_CATEGORY) : 0; Log.i(this.getClass().getName(), "Received message '" + action + "' for picto " + picto_id + " (cat " + picto_cat + ", attrs: " + attrs_picto); for (iVocabularyListener listener: this.listeners) listener.change(action.equals(action_update) ? iVocabularyListener.action.update : action.equals(action_add) ? iVocabularyListener.action.add : iVocabularyListener.action.delete , picto_cat, picto_id, stu_picto); } catch (JSONException e) { Log.e(this.getClass().getCanonicalName(), e.getClass().getCanonicalName() + "--" + e); } }}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/grammar/iLocalPicto.java deleted 100644 → 0
package com.yottacode.pictogram.grammar;
import com.yottacode.pictogram.dao.Picto;
/**
* Created by Fernando on 14/03/2016.
*/
public interface iLocalPicto {
public void saved(Picto localPicto);
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/grammar/iVocabularyListener.java deleted 100644 → 0
package com.yottacode.pictogram.grammar;
import com.yottacode.pictogram.dao.Picto;
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.Hashtable;
import java.util.LinkedList;
/**
* Vocabulary Listener
* @author Fernando Martinez Santiago
* @version 1.0
*/
public interface iVocabularyListener {
public enum action {delete,add,update}
public void change(iVocabularyListener.action action, int picto_cat, int picto_id, JSONObject args);
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/CustomList.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import android.app.Activity;
import android.graphics.Bitmap;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import com.yottacode.pictogram.R;
import java.util.Vector;
/**
* Creates a View for each student on the list with a photo and his/her name.
* It uses list_single.xml for the layout creation.
*/
public class CustomList extends ArrayAdapter<String>{
private final Activity context;
private final String[] name_surname;
private final Vector<Bitmap> images;
/**
* @param context Context used for rendering the view
* @param name_surname List of students' names
* @param images List of students' photos
*/
public CustomList(Activity context,
String[] name_surname, Vector<Bitmap> images) {
super(context, R.layout.list_single, name_surname);
this.context = context;
this.name_surname = name_surname;
this.images = images;
}
/**
* @param position Student position in the name_surname/images arrays
* @param view @TODO not being used
* @param parent @TODO not being used
* @return The rendered student view
*/
@Override
public View getView(int position, View view, ViewGroup parent) {
LayoutInflater inflater = context.getLayoutInflater();
View rowView= inflater.inflate(R.layout.list_single, null, true);
TextView txtTitle = (TextView) rowView.findViewById(R.id.loginStudentName);
ImageView imageView = (ImageView) rowView.findViewById(R.id.loginStudentPhoto);
txtTitle.setText(name_surname[position]);
//imageView.setImageResource(R.drawable.user);
imageView.setImageBitmap(images.elementAt(position));
return rowView;
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/LoginActivity.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import android.annotation.TargetApi;
import android.content.Intent;
import android.os.AsyncTask;
import android.support.v4.app.FragmentActivity;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.net.ImgDownloader;
import com.yottacode.pictogram.net.iImgDownloaderListener;
import com.yottacode.pictogram.tools.Img;
import com.yottacode.pictogram.tools.PCBcontext;
import com.yottacode.tools.GUITools;
import java.io.IOException;
import java.util.Vector;
/**
* LoginActivity show the login window to select the student and supervisor
* It uses device to read the token value
*/
public class LoginActivity extends FragmentActivity {
// String constant for logs
private final String LOG_TAG = this.getClass().getSimpleName(); // Or .getCanonicalName()
/**
* If there is Internet connection it calls the WS to recover the pairs student-supervisor
* @param savedInstanceState
*/
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_login);
// Enable logout button
final Button logoutButton = (Button) findViewById(R.id.loginTopbarLogout);
logoutButton.setEnabled(true);
logoutButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent serialActivity = new Intent(getBaseContext(), SerialActivity.class);
serialActivity.putExtra("resetPrevUser", true);
startActivity(serialActivity);
}
});
// Set supervisor information on topbar
final TextView supervisorFullNameView = (TextView) findViewById(R.id.loginTopbarSupervisorFullName);
final TextView supervisorUserNameView = (TextView) findViewById(R.id.loginTopbarSupervisorUserName);
final ImageView supervisorPhotoView = (ImageView) findViewById(R.id.loginTopbarSupervisorPhoto);
supervisorFullNameView.setText(
this.getIntent().getStringExtra("name") + " " +
this.getIntent().getStringExtra("surname"));
supervisorUserNameView.setText(this.getIntent().getStringExtra("email"));
final Vector<Img> imgs = new Vector<>(1);
imgs.add(new Img(
this.getIntent().getIntExtra("sup_id", -1),
this.getIntent().getStringExtra("pic"),
Img.SUPERVISOR
));
ImgDownloader downloader = new ImgDownloader(this, new iImgDownloaderListener() {
@Override
public void loadComplete() {
try {
supervisorPhotoView.setImageBitmap(
imgs.get(0).get_bitmap(PCBcontext.getContext())
);
supervisorPhotoView.invalidate();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void loadImg(Img image) {}
@Override
public void error(Exception e) {
GUITools.show_alert(PCBcontext.getContext(), R.string.serverError, e.getMessage());
Log.e(this.getClass().getCanonicalName(), "Server error:"+ e.getLocalizedMessage());
}
}, ImgDownloader.tsource.remote);
downloader.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, imgs);
}
@Override
protected void onResume() {
super.onResume();
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/MainActivity.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.provider.Settings;
import android.util.Log;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Toast;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.dao.Device;
import com.yottacode.pictogram.dao.LoginException;
import com.yottacode.pictogram.dao.PCBDBHelper;
import com.yottacode.pictogram.dao.User;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Vector;
public class MainActivity extends Activity {
// String constant for logs
private final String LOG_TAG = this.getClass().getSimpleName(); // Or .getCanonicalName()
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
// For deactivating the lock screen (just before setContentView)
getWindow().addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
PCBcontext.init(this);
Log.d(LOG_TAG, "PCBcontext iniciado.");
Intent serialActivity = new Intent(this, SerialActivity.class);
serialActivity.putExtra("resetPrevUser", false);
startActivity(serialActivity);
}
@Override
protected void onDestroy() {
super.onDestroy();
PCBcontext.getNetService().closeNotifyStatus();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/PictoGridAdapter.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import android.annotation.TargetApi;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Build;
import android.os.Bundle;
import android.speech.tts.TextToSpeech;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.FrameLayout;
import android.widget.GridView;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import java.io.IOException;
import java.util.LinkedList;
public class PictoGridAdapter extends ArrayAdapter {
private LinkedList<Picto> pictoLinkedList;
private final String LOG_TAG = this.getClass().getSimpleName();
public PictoGridAdapter(LinkedList<Picto> pictoLinkedList){
super(PCBcontext.getContext(), PictoItemViewGenerator.LAYOUT, pictoLinkedList);
this.pictoLinkedList = pictoLinkedList;
}
@Override
public int getCount() {
return this.pictoLinkedList.size();
}
@Override
public Picto getItem(int position) {
return this.pictoLinkedList.get(position);
}
@Override
public long getItemId(int position) {
return 0;
}
public void deleteAll() {
this.pictoLinkedList.clear();
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
return PictoItemViewGenerator.getPictoView(
this.pictoLinkedList.get(position),
convertView,
parent
);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public void ttsPicto(Picto p, TextToSpeech tts) {
if (p.is_enabled()) {
String input = p.get_translation();
Bundle params = new Bundle();
params.putString(TextToSpeech.Engine.KEY_PARAM_VOLUME, "1");
tts.speak(input, TextToSpeech.QUEUE_FLUSH, params, null);
}
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/PictoItemViewGenerator.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import java.io.IOException;
/**
* This class is used for generating PictoViews which will be inserted inside a picto grid
* or a picto tape.
*/
public class PictoItemViewGenerator {
public static final int LAYOUT = R.layout.picto_grid_item;
public static View getPictoView(Picto picto, View convertView, ViewGroup parent) {
if (convertView == null) {
convertView = LayoutInflater.from(parent.getContext()).inflate(LAYOUT, parent, false);
}
RelativeLayout layoutWrapper = (RelativeLayout) convertView.findViewById(R.id.picto_grid_item_layout_wrapper);
FrameLayout layout = (FrameLayout) convertView.findViewById(R.id.picto_grid_item_layout);
ImageView pictoImage = (ImageView) convertView.findViewById(R.id.picto_grid_item_image);
ImageView redCrossImage = (ImageView) convertView.findViewById(R.id.picto_grid_item_redcross);
layoutWrapper.setVisibility(View.GONE);
layoutWrapper.setBackground(null);
layoutWrapper.setAlpha(0.25f);
layout.setBackgroundColor(convertView.getResources()
.getColor(R.color.picto_default_background));
redCrossImage.setVisibility(View.GONE);
pictoImage.setScaleX(1.0f);
pictoImage.setScaleY(1.0f);
pictoImage.setVisibility(View.GONE);
if (picto == null) {
if (PCBcontext.getPcbdb().getCurrentUser().is_supervisor()) {
layoutWrapper.setVisibility(View.VISIBLE);
layoutWrapper.setBackground(convertView.getResources()
.getDrawable(R.drawable.picto_grid_item_border));
}
} else {
if (!picto.is_invisible() && !picto.is_disabled()) {
layoutWrapper.setAlpha(1.00f);
}
try {
pictoImage.setImageBitmap(picto.get_bitmap(PCBcontext.getContext()));
if (!picto.is_invisible() || PCBcontext.getPcbdb().getCurrentUser().is_supervisor()) {
layoutWrapper.setVisibility(View.VISIBLE);
pictoImage.setVisibility(View.VISIBLE);
layoutWrapper.setBackground(convertView.getResources()
.getDrawable(R.drawable.picto_grid_item_border));
if (picto.is_magnify()) {
pictoImage.setScaleX(1.2f);
pictoImage.setScaleY(1.2f);
}
if (picto.is_disabled()) {
redCrossImage.setVisibility(View.VISIBLE);
}
if (picto.is_category()) {
layout.setBackgroundColor(picto.get_color());
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
return convertView;
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/PictogramActivity.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import android.app.Activity;
import android.app.AlertDialog;
import android.database.Cursor;
import android.content.ClipData;
import android.content.ClipDescription;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.speech.tts.TextToSpeech;
import android.speech.tts.UtteranceProgressListener;
import android.text.InputType;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.DragEvent;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.Animation;
import android.view.animation.TranslateAnimation;
import android.widget.AdapterView;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.GridView;
import android.widget.ImageButton;
import android.widget.RelativeLayout;
import android.widget.Toast;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.action.PictosAction;
import com.yottacode.pictogram.action.TalkAction;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.grammar.Vocabulary;
import com.yottacode.pictogram.grammar.iLocalPicto;
import com.yottacode.pictogram.grammar.iVocabularyListener;
import com.yottacode.pictogram.net.PictoUploader;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONObject;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
public class PictogramActivity extends Activity implements iVocabularyListener, TextToSpeech.OnInitListener {
// Main layout for this activity
RelativeLayout mainLayout;
// Adapter for de grid showing the categories grid (and main pictos)
PictoGridAdapter pictoMainGridAdapter;
// Grid showing the categories grid (and main pictos)
GridView pictoMainGridView;
// Adapter for the grid showing pictos from a category (initially hidden)
PictoGridAdapter pictoCategoryGridAdapter;
// Grid showing pictos from a category (initially hidden)
GridView pictoCategoryGridView;
// Adapter for the tape view (list of pictos to send to the server)
TapeAdapter tapeAdapter;
// Tape view (list of pictos to send to the server)
GridView tapeGridView;
// Current picto category, if not null the corresponding category grid will be shown
Picto currentCategory;
// Object used for reading text
TextToSpeech tts;
// Element used for loading new pictos (while changing categories)
Vocabulary vocabulary;
// TODO describe this variable
static final int SELECT_PICTURE = 1;
// For disabling volume button (See method at the end of the class)
private final List blockedKeys = new ArrayList(Arrays.asList(KeyEvent.KEYCODE_VOLUME_DOWN, KeyEvent.KEYCODE_VOLUME_UP));
// String constant for logs
private final String LOG_TAG = this.getClass().getSimpleName(); // Or .getCanonicalName()
// Count for delete long press (hidden exit)
private int count_deletelong = 0;
// Animation for hidding the picto category view
Animation hidePictoMainViewAnimation;
// Animation for showing the picto category view
Animation showPictoMainViewAnimation;
// Button used for showing the picto category view
ImageButton showPictoCategoriesViewButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_pictogram);
this.mainLayout = (RelativeLayout) findViewById(R.id.pictogramLayout);
this.currentCategory = null;
this.count_deletelong = 0;
this.vocabulary = PCBcontext.getVocabulary();
this.vocabulary.listen(PCBcontext.getRoom(), this);
if (this.vocabulary != null && this.vocabulary.size() > 0) {
Log.d(LOG_TAG, "Vocabulario correcto de tam:" + vocabulary.size());
}
this.tapeAdapter = new TapeAdapter();
this.tapeGridView = (GridView) this.findViewById(R.id.tape_grid_view);
this.tapeGridView.setAdapter(this.tapeAdapter);
this.pictoMainGridAdapter = new PictoGridAdapter(new LinkedList<Picto>());
this.pictoMainGridView = (GridView) this.findViewById(R.id.picto_main_grid_view);
this.pictoMainGridView.setAdapter(this.pictoMainGridAdapter);
this.pictoCategoryGridAdapter = new PictoGridAdapter(new LinkedList<Picto>());
this.pictoCategoryGridView = (GridView) this.findViewById(R.id.picto_category_grid_view);
this.pictoCategoryGridView.setAdapter(this.pictoCategoryGridAdapter);
// @TODO take this value from user configuration (0: normal, 1: large)
int pictogramSize = 0;
if (pictogramSize == 0) {
this.pictoMainGridView.setNumColumns(10);
this.pictoCategoryGridView.setNumColumns(10);
} else if (pictogramSize == 1) {
this.pictoMainGridView.setNumColumns(4);
this.pictoCategoryGridView.setNumColumns(4);
}
// tts = new TextToSpeech(this, this, "IVONA Text-to-Speech HQ");
tts = new TextToSpeech(this, this);
tts.setOnUtteranceProgressListener(new OnTTSEndListener());
this.tapeGridView.setOnDragListener(new OnPictoDragListener());
this.pictoMainGridView.setOnDragListener(new OnPictoDragListener());
this.pictoCategoryGridView.setOnDragListener(new OnPictoDragListener());
this.pictoMainGridView.setOnItemClickListener(new OnPictoClickListener());
this.pictoCategoryGridView.setOnItemClickListener(new OnPictoClickListener());
this.pictoMainGridView.setOnItemLongClickListener(new OnPictoLongClickListener());
this.pictoCategoryGridView.setOnItemLongClickListener(new OnPictoLongClickListener());
final ImageButton deleteButton = (ImageButton) findViewById(R.id.button_delete);
final ImageButton ttsButton = (ImageButton) findViewById(R.id.button_tts);
ttsButton.setOnClickListener(new OnTTSButtonClickListener());
deleteButton.setOnClickListener(new OnDeleteButtonClickListener());
deleteButton.setOnLongClickListener(new OnDeleteButtonLongClickListener());
this.showPictoCategoriesViewButton = (ImageButton) this.findViewById(R.id.showPictoCategoriesViewButton);
this.showPictoCategoriesViewButton.setOnClickListener(new OnShowPictoCategoriesViewButtonClick());
this.generateAnimations();
if (this.currentCategory != null) {
this.hidePictoMainGridView();
} else {
this.showPictoMainGridView();
}
}
@Override
public void onInit(int status) {
if (status == TextToSpeech.SUCCESS) {
tts.setLanguage(Locale.getDefault());
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (tts != null){
tts.shutdown();
}
// PCBcontext.getNetService().closeNotifyStatus();
}
/**
* Creates the animations for moving the picto view
*/
private void generateAnimations() {
DisplayMetrics displayMetrics = new DisplayMetrics();
this.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int animationDuration = 400;
int animationWidth = displayMetrics.widthPixels;
this.hidePictoMainViewAnimation = new TranslateAnimation(0, -animationWidth, 0, 0);
this.hidePictoMainViewAnimation.setDuration(animationDuration);
this.hidePictoMainViewAnimation.setFillAfter(true);
this.hidePictoMainViewAnimation.setInterpolator(new AccelerateDecelerateInterpolator());
this.hidePictoMainViewAnimation.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {}
@Override
public void onAnimationEnd(Animation animation) {
pictoMainGridView.setTranslationZ(-1000.0f);
pictoMainGridView.setVisibility(View.GONE);
}
@Override
public void onAnimationRepeat(Animation animation) {}
});
this.showPictoMainViewAnimation = new TranslateAnimation(-animationWidth, 0, 0, 0);
this.showPictoMainViewAnimation.setDuration(animationDuration);
this.showPictoMainViewAnimation.setFillAfter(true);
this.showPictoMainViewAnimation.setInterpolator(new AccelerateDecelerateInterpolator());
this.showPictoMainViewAnimation.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
pictoMainGridView.setTranslationZ(1000.0f);
pictoMainGridView.setVisibility(View.VISIBLE);
}
@Override
public void onAnimationEnd(Animation animation) {}
@Override
public void onAnimationRepeat(Animation animation) {}
});
}
/**
* Show the main category grid view and hide the pictoGrid, unloading all pictos
* if necesary.
*/
private void showPictoMainGridView() {
Log.d(LOG_TAG, "Showing pictoMainGridView");
this.pictoMainGridAdapter.clear();
this.pictoMainGridAdapter.addAll(this.sort(this.vocabulary.startSentence()));
this.pictoMainGridAdapter.notifyDataSetChanged();
this.pictoMainGridView.setEnabled(true);
this.pictoCategoryGridView.setEnabled(false);
if (this.pictoMainGridView.getAnimation() == this.hidePictoMainViewAnimation) {
this.pictoMainGridView.startAnimation(this.showPictoMainViewAnimation);
}
this.currentCategory = null;
}
/**
* Hides the main category grid view and show a concrete category (this.currentCategory)
*/
private void hidePictoMainGridView() {
Log.d(LOG_TAG, "Hiding pictoMainGridView");
this.pictoCategoryGridAdapter.clear();
this.pictoCategoryGridAdapter.addAll(this.sort(this.vocabulary.next(this.currentCategory)));
this.pictoCategoryGridAdapter.notifyDataSetChanged();
if (this.currentCategory.get_color() != -1) {
this.pictoCategoryGridView.setBackgroundColor(this.currentCategory.get_color());
}
this.pictoMainGridView.setEnabled(false);
this.pictoCategoryGridView.setEnabled(true);
if (this.pictoMainGridView.getAnimation() != this.hidePictoMainViewAnimation) {
this.pictoMainGridView.startAnimation(this.hidePictoMainViewAnimation);
}
}
/**
* Returns pictoCategoryGridAdapter or pictoMainGridAdapter depending on the current View
*/
private PictoGridAdapter getCurrentPictoGridAdapter() {
return (currentCategory == null) ? this.pictoMainGridAdapter : this.pictoCategoryGridAdapter;
}
/**
* Order a linked list of pictos with "blank spaces" between them
* @param list
* @return
*/
public LinkedList<Picto> sort(LinkedList<Picto> list){
if (list == null) {
list = new LinkedList<>();
}
LinkedList<Picto> ll = new LinkedList<>();
// This is to show the pictos ordered in the 2D Array that represents the panel
int rows = getResources().getInteger(R.integer.rows);
int cols = getResources().getInteger(R.integer.columns);
Picto[][] mp = new Picto[rows][cols];
for (Picto p : list) {
if (PCBcontext.getPcbdb().getCurrentUser().has_categories()) {
if (p.get_column() != -1 && p.get_row() != -1) {
mp[p.get_column()][p.get_row()] = p;
}
} else {
if (p.getFreeColumn() != -1 && p.getFreeRow() != -1) {
mp[p.getFreeColumn()][p.getFreeRow()] = p;
}
}
}
try {
/*
Picto blankPicto = new Picto(0,
"/symbolstx/color/png/arts_crafts/eraser.png", // TODO Definir imagen para picto en blanco
"Blank picto",
"{\"magnify\":false,\"highlight\":false,\"coord_y\":1,\"id_cat\":12303,\"status\":\"invisible\",\"coord_x\":4}");
*/
for(int i=0; i<rows; i++){
for(int j=0; j<cols; j++){
if(mp[i][j] != null) ll.add(mp[i][j]);
else ll.add(null); // Add the "blank picto" simulating an empty position
}
}
}
catch (Exception e) {
e.printStackTrace();
}
return ll;
}
/**
* Background task that updates the ui into the main thread
*/
public void refresh() {
runOnUiThread(new Runnable() {
@Override
public void run() {
if (currentCategory != null) {
hidePictoMainGridView();
} else {
showPictoMainGridView();
}
}
});
}
/**
* @TODO check documentation
* De la interfaz iVocabularyListener
*/
@Override
public void change(action action, int picto_cat, int picto_id, JSONObject args) {
Log.d(LOG_TAG, "Vocabulary action listened: " + action);
if(args!=null) Log.d(LOG_TAG, "args: " + args.toString());
refresh();
}
/**
* Disable Back Button --> Kiosk mode
*/
@Override
public void onBackPressed() {
// Inflate the layout for the AlertDialog
View dialogEscape = View.inflate(this, R.layout.dialog_escape, null);
final CheckBox checkBox = (CheckBox) dialogEscape.findViewById(R.id.checkBox);
final EditText input = (EditText) dialogEscape.findViewById(R.id.editText);
// Build de AlertDialog
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getResources().getString(R.string.exitPictogram));
builder.setView(dialogEscape);
// Set up the buttons
builder.setPositiveButton(getResources().getString(R.string.ok), new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
String m_Text = input.getText().toString();
String keyword = PCBcontext.getDevice().getKeyword();
if (m_Text.equalsIgnoreCase(keyword)) {
// Change the password
if(checkBox.isChecked()){
// Show a new dialog
View dialogChangeEscapeCode = View.inflate(PCBcontext.getContext(), R.layout.dialog_change_escape_code, null);
final EditText input1 = (EditText) dialogChangeEscapeCode.findViewById(R.id.editText1);
final EditText input2 = (EditText) dialogChangeEscapeCode.findViewById(R.id.editText2);
// Build the AlertDialog
AlertDialog.Builder builder = new AlertDialog.Builder(PCBcontext.getContext());
builder.setTitle(PCBcontext.getContext().getResources().getString(R.string.newEscapeCode));
builder.setView(dialogChangeEscapeCode);
// Set up the buttons
builder.setPositiveButton(getResources().getString(R.string.ok), new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// Retrieve the text of the 2 password inputs
String m_Text1 = input1.getText().toString();
String m_Text2 = input2.getText().toString();
// If they are equal
if (m_Text1.equalsIgnoreCase(m_Text2)) {
// Change the keyword
PCBcontext.getDevice().setKeyword(m_Text1);
Toast.makeText(PCBcontext.getContext(), getResources().getString(R.string.codeModified), Toast.LENGTH_SHORT).show();
// And exit PictogramActivity
finish();
} else Toast.makeText(PCBcontext.getContext(), getResources().getString(R.string.codesNotEqual), Toast.LENGTH_SHORT).show();
}
});
builder.setNegativeButton(getResources().getString(R.string.cancel), new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
builder.show();
}else {
// Finish this Activity it the code is ok and is not checked the checkbox to change the code
finish();
/*
// Start the main activity
Intent mainActivity = new Intent(context, MainActivity.class);
startActivity(mainActivity);
*/
}
// Wrong code
} else Toast.makeText(PCBcontext.getContext(),getResources().getString(R.string.wrongCode), Toast.LENGTH_SHORT).show();
}
});
builder.setNegativeButton(getResources().getString(R.string.cancel), new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
builder.show();
}
/**
* Disable long power button press (system menu)
* @param hasFocus
*/
@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
if(!hasFocus) {
// Close every kind of system dialog
Intent closeDialog = new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
sendBroadcast(closeDialog);
}
}
/**
* Disable volume button on key event
* @param event
*/
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
if (blockedKeys.contains(event.getKeyCode())) {
return true;
} else {
return super.dispatchKeyEvent(event);
}
}
/* *********************************************************************************************
* Event listener classes
* ********************************************************************************************/
/**
* Class used for dragging pictos to the tape
*/
private class OnPictoDragListener implements View.OnDragListener {
//Drawable normalShape = getResources().getDrawable(R.drawable.normal_shape);
//Drawable targetShape = getResources().getDrawable(R.drawable.target_shape);
@Override
public boolean onDrag(View v, DragEvent event) {
// Handles each of the expected events
switch (event.getAction()) {
//signal for the start of a drag and drop operation.
case DragEvent.ACTION_DRAG_STARTED:
// do nothing
Log.d("Drag:", "1 Drag started");
break;
//the drag point has entered the bounding box of the View
case DragEvent.ACTION_DRAG_ENTERED:
//v.setBackground(targetShape); //change the shape of the view
Log.d("Drag:", "2 Drag entered");
break;
//the user has moved the drag shadow outside the bounding box of the View
case DragEvent.ACTION_DRAG_EXITED:
//v.setBackground(normalShape); //change the shape of the view back to normal
Log.d("Drag:", "3 Drag exited");
break;
//drag shadow has been released,the drag point is within the bounding box of the View
case DragEvent.ACTION_DROP:
Log.d("Drag:", "4 Drop");
View view = (View) event.getLocalState();
ViewGroup viewgroup = (ViewGroup) view.getParent();
int position = Integer.parseInt((String) event.getClipDescription().getLabel());
// if the view is the tape_grid_view, we accept the drag item
// Destino tape_grid_view y origen panel_grid_view
if(v == findViewById(R.id.tape_grid_view) && viewgroup == findViewById(R.id.picto_category_grid_view)) {
Log.d("Drag:", "Posición: " + position);
Picto p = pictoCategoryGridAdapter.getItem(position);
if(!p.is_category()) {
currentCategory = null;
tapeAdapter.addItem(p);
tapeAdapter.notifyDataSetChanged();
showPictoMainGridView();
PCBcontext.getActionLog().log(new TalkAction(TalkAction.ADD, p));
}
}
// Si el destino es el panel y el origen la cinta de frase
else if(v == findViewById(R.id.picto_category_grid_view) && viewgroup == findViewById(R.id.tape_grid_view)){
Log.d("Drag:", "Posición: " + position);
Picto p = tapeAdapter.getItem(position);
tapeAdapter.deleteItem(position);
tapeAdapter.notifyDataSetChanged();
}
break;
//the drag and drop operation has concluded.
case DragEvent.ACTION_DRAG_ENDED:
Log.d("Drag:", "5 Drag ended");
// v.setBackground(normalShape); //go back to normal shape
default:
break;
}
return true;
}
}
/**
* Class used for picto clicking feedback
*/
private class OnPictoClickListener implements AdapterView.OnItemClickListener{
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Picto p = getCurrentPictoGridAdapter().getItem(position);
if (p != null && !p.is_invisible() && p.is_enabled()) {
Log.d(LOG_TAG, "Clic en picto: " + p.toString());
//Log.d(LOG_TAG, "STATUS: " + p.get_status());
//QUITAR PARA QUE HABLE pictoCategoryGridAdapter.ttsPicto(p, tts);
// If is not the blank picto, it isn't invisible or disabled
if (p.get_id() != 0 &&
!p.get_status().equalsIgnoreCase("invisible") &&
!p.get_status().equalsIgnoreCase("disabled")) {
LinkedList<Picto> ll = sort(PCBcontext.getVocabulary().next(p));
//LinkedList<Picto> ll = vocabulary.next(p);
Log.d(LOG_TAG, "Lista de pictos recuperada: " + ll.toString());
int maxInTape = getResources().getInteger(R.integer.maxInTape);
// If the picto is a category
if (p.is_category()) {
currentCategory = p;
PCBcontext.getActionLog().log(new TalkAction(TalkAction.SELECT, p));
hidePictoMainGridView();
} else if (tapeAdapter.getCount() < maxInTape) {
currentCategory = null;
tapeAdapter.addItem(p);
tapeAdapter.notifyDataSetChanged();
PCBcontext.getActionLog().log(new TalkAction(TalkAction.ADD, p));
showPictoMainGridView();
}
}
}
}
}
/**
* Class used for long pressing on pictos (start drag)
*/
private class OnPictoLongClickListener implements AdapterView.OnItemLongClickListener {
public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
if (PCBcontext.getPcbdb().getCurrentUser().is_supervisor()) {
// Si es supervisor al hacer longClick deshabilito ese pictograma o lo habilito
Picto p = getCurrentPictoGridAdapter().getItem(position);
if (p == null) {
// No tengo pictograma. Abro una nueva ventana de selección desde el Carrete del device si no es categoria
if (currentCategory != null || !PCBcontext.getPcbdb().getCurrentUser().has_categories()) {
Log.d(LOG_TAG, "No tengo pictograma. Abro carrete...");
int cols = getResources().getInteger(R.integer.columns);
addPicto(position % cols, (int) (position / cols));
}
else
Toast.makeText(PictogramActivity.this, PictogramActivity.this.getResources().getString(R.string.notNewCats), Toast.LENGTH_SHORT).show();
} else {
p.alter_status();
getCurrentPictoGridAdapter().notifyDataSetChanged();
}
} else {
ClipData.Item item = new ClipData.Item("" + position);
String[] mimeTypes = {ClipDescription.MIMETYPE_TEXT_PLAIN};
ClipData data = new ClipData("" + position, mimeTypes, item);
Picto p = getCurrentPictoGridAdapter().getItem(position);
if (p != null && !p.is_invisible() && p.is_enabled()) {
// If is not the blank picto, it isn't invisible or disabled
if (p.get_id() != 0 &&
!p.get_status().equalsIgnoreCase("invisible") &&
!p.get_status().equalsIgnoreCase("disabled") &&
tapeAdapter.getCount() < 8) {
View.DragShadowBuilder shadowBuilder = new View.DragShadowBuilder(view);
view.startDrag(data, //data to be dragged
shadowBuilder, //drag shadow
view, //local data about the drag and drop operation
0 //no needed flags
);
//view.setVisibility(View.INVISIBLE);
}
}
}
return true;
}
}
/**
* Class used for reading pictos on TTS button click
*/
private class OnTTSButtonClickListener implements View.OnClickListener {
@Override
public void onClick(View arg0) {
LinkedList<Picto> lp = tapeAdapter.getAll();
PCBcontext.getActionLog().log(new PictosAction(lp));
tapeAdapter.ttsAllNew(tts);
}
}
/**
* Class for listening the TTS start/end/error events.
* It clears the tape and shows the category grid when the speech has finished or errored.
*/
private class OnTTSEndListener extends UtteranceProgressListener {
@Override
public void onStart(String utteranceId) {
Log.d(LOG_TAG, "TTS tape read start");
}
@Override
public void onDone(String utteranceId) {
Log.d(LOG_TAG, "TTS tape read end");
this.finishSpeech();
}
@Override
public void onError(String utteranceId) {
Log.d(LOG_TAG, "TTS tape read error");
this.finishSpeech();
}
private void finishSpeech() {
runOnUiThread(new Runnable() {
@Override
public void run() {
tapeAdapter.deleteAll();
tapeAdapter.notifyDataSetChanged();
showPictoMainGridView();
}
});
}
}
/**
* Class used for canceling a list of pictos on the tape
*/
private class OnDeleteButtonClickListener implements View.OnClickListener {
@Override
public void onClick(View arg0) {
if (tapeAdapter.hasElements()) {
Picto p = tapeAdapter.getLastItem();
// Call to static log method
PCBcontext.getActionLog().log(new TalkAction(TalkAction.DELETE, p));
// Send websocket action
tapeAdapter.deleteLastView();
tapeAdapter.notifyDataSetChanged();
}
}
}
/**
* Class used for long click on delete button. When a press count reaches 3, the application
* exists.
*/
private class OnDeleteButtonLongClickListener implements View.OnLongClickListener {
@Override
public boolean onLongClick(View v) {
count_deletelong++;
if (count_deletelong >= 3) {
PCBcontext.unset_user();
// Paso un parámetro a la SerialActivity, para controlar de dónde viene
Intent serialActivity = new Intent(getBaseContext(), SerialActivity.class);
serialActivity.putExtra("resetPrevUser", true);
startActivity(serialActivity);
}
return false;
}
}
/**
* Listener used for bringing back the picto categories grid when clicked.
*/
private class OnShowPictoCategoriesViewButtonClick implements View.OnClickListener {
@Override
public void onClick(View v) {
showPictoMainGridView();
}
}
/* *********************************************************************************************
* Methods for adding a new picto from pcb
* ********************************************************************************************/
/**
* add a local picto from pcb
* @param row
* @param col
*/
public void addPicto(int row, int col) {
Intent intent = new Intent(Intent.ACTION_PICK);
intent.setType("image/*");
if (PCBcontext.getPcbdb().getCurrentUser().has_categories()) {
this.getIntent().putExtra(Picto.JSON_ATTTRS.ROW, row);
this.getIntent().putExtra(Picto.JSON_ATTTRS.COLUMN, col);
} else {
this.getIntent().putExtra(Picto.JSON_ATTTRS.FREE_ROW, row);
this.getIntent().putExtra(Picto.JSON_ATTTRS.FREE_COLUMN, col);
}
startActivityForResult(intent, SELECT_PICTURE);
}
/**
* función para la edición de un texto asociado a una nueva imagen y guardar el nuevo picto
*/
public void chooseTextAndSavePicto(final String selectedImagePath, final int row, final int col, final int freeRow, final int freeColumn) {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getResources().getString(R.string.enterImgLabel));
// Set up the input
final EditText input = new EditText(this);
input.setInputType(InputType.TYPE_CLASS_TEXT);
builder.setView(input);
// Set up the buttons
builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
int cat = PictogramActivity.this.currentCategory != null
? PictogramActivity.this.currentCategory.get_id()
: Picto.NO_CATEGORY;
PCBcontext.getVocabulary().saveLocalPicto(
selectedImagePath,
input.getText().toString(),
cat,
row,
col,
freeRow,
freeColumn,
new iLocalPicto() {
@Override
public void saved(Picto localPicto) {
PictogramActivity.this.refresh();
try {
new PictoUploader(localPicto).upload(PictogramActivity.this);
} catch (IOException e) {
Log.e(Vocabulary.class.getCanonicalName(), e.getMessage());
}
}
});
}
});
builder.show();
}
/**
* Función para la selección de una foto del carrete
* @param requestCode
* @param resultCode
* @param data
*/
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (resultCode == Activity.RESULT_OK) {
if (requestCode == SELECT_PICTURE) {
String selectedImagePath;
Uri selectedImageUri = data.getData();
selectedImagePath = getPath(selectedImageUri);
int row=this.getIntent().getIntExtra(Picto.JSON_ATTTRS.ROW, -1);
int col=this.getIntent().getIntExtra(Picto.JSON_ATTTRS.COLUMN, -1);
int freeRow = this.getIntent().getIntExtra(Picto.JSON_ATTTRS.FREE_ROW, -1);
int freeColumn = this.getIntent().getIntExtra(Picto.JSON_ATTTRS.FREE_COLUMN, -1);
Log.i(this.getClass().getCanonicalName(), "0 Picto x y " + " " + row + " " + col);
this.getIntent().removeExtra(Picto.JSON_ATTTRS.ROW);
this.getIntent().removeExtra(Picto.JSON_ATTTRS.COLUMN);
this.getIntent().removeExtra(Picto.JSON_ATTTRS.FREE_ROW);
this.getIntent().removeExtra(Picto.JSON_ATTTRS.FREE_COLUMN);
chooseTextAndSavePicto(selectedImagePath, row, col, freeRow, freeColumn);
}
}
}
/**
* Función para la selección de una foto del carrete
* @param uri
* @return
*/
static public String getPath(Uri uri) {
if( uri == null ) {
return null;
}
// this will only work for images selected from gallery
String[] projection = { MediaStore.Images.Media.DATA };
Cursor cursor = PCBcontext.getContext().getContentResolver().query(uri, projection, null, null, null);
if( cursor != null ){
int column_index = cursor
.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
cursor.moveToFirst();
return cursor.getString(column_index);
}
return uri.getPath();
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/SplashScreenActivity.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import java.util.Timer;
import java.util.TimerTask;
import android.app.Activity;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;
import com.yottacode.pictogram.R;
public class SplashScreenActivity extends Activity {
// Set the duration of the splash screen
private static final long SPLASH_SCREEN_DELAY = 3000;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Set landscape orientation
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
// Hide title bar
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_splash_screen);
TimerTask task = new TimerTask() {
@Override
public void run() {
// Start the next activity
Intent mainIntent = new Intent().setClass(
SplashScreenActivity.this, MainActivity.class);
startActivity(mainIntent);
// Intent pictogramActivity = new Intent().setClass(
// SplashScreenActivity.this, PictogramActivity.class);
//pictogramActivity.putExtra();
// seguir: hay que pasarle el estudiante y el supervisor, para cargar la colección, etc...
// startActivity(pictogramActivity);
// Close the activity so the user won't able to go back this
// activity pressing Back button
finish();
}
};
// Simulate a long loading process on application startup.
Timer timer = new Timer();
timer.schedule(task, SPLASH_SCREEN_DELAY);
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/StudentFragmentGrid.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.zip.Inflater;
import android.app.Fragment;
import android.app.ProgressDialog;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.GridView;
import com.yottacode.net.RestapiWrapper;
import com.yottacode.net.iRestapiListener;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.dao.LoginException;
import com.yottacode.pictogram.dao.User;
import com.yottacode.pictogram.net.ImgDownloader;
import com.yottacode.pictogram.net.iImgDownloaderListener;
import com.yottacode.pictogram.tools.Img;
import com.yottacode.pictogram.tools.PCBcontext;
import com.yottacode.tools.GUITools;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
/**
* StudentFragmentGrid implements the gridview with the students
* @author Miguel Ángel García Cumbreras
* @author Fernando
* @version 1.1
*/
public class StudentFragmentGrid extends Fragment{
final String TAG_ID = "id";
final String TAG_USERNAME = "username";
final String TAG_NAME = "name";
final String TAG_SURNAME = "surname";
final String TAG_GENDER = "gender";
final String TAG_PIC = "pic";
final String TAG_LANG = "lang";
final String TAG_ATTRIBUTES = "attributes";
final String TAG_SUPERVISION="supervision";
Vector<Integer> idStudents;
String nameStudents[];
Vector<Bitmap> imageStudents;
private Vector<JSONObject> downloaded_students;
private final String LOG_TAG = this.getClass().getSimpleName(); // Or .getCanonicalName()
GridView gridView;
boolean onlineStudentsOK=false;
private void showStudentsGrid(){
CustomList adapter = new CustomList(getActivity(), nameStudents, imageStudents);
gridView.setAdapter(adapter);
gridView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> arg0, View arg1, int pos, long arg3) {
set_user(pos);
}
});
}
private void set_user(int i) {
Boolean offline = getActivity().getIntent().getBooleanExtra("offline", false);
if (offline) {
User currentUser= null;
try {
currentUser = PCBcontext.getDevice().findUser(idStudents.get(i),getActivity().getIntent().getIntExtra("sup_id", 0));
} catch (JSONException e) {
e.printStackTrace();
Log.e(StudentFragmentGrid.this.getClass().getCanonicalName(), e.getMessage());
}
PCBcontext.set_user(currentUser, null, null);
Intent pictogramActivity = new Intent(getActivity(), PictogramActivity.class);
startActivity(pictogramActivity);
} else
new_user(i);
}
private void new_user(int i) {
JSONObject st = this.downloaded_students.get(i);
Intent intent = getActivity().getIntent();
try {
User new_user = new User(
st.getInt(TAG_ID),
st.getString(TAG_USERNAME),
null,
st.getString(TAG_NAME),
st.getString(TAG_SURNAME),
st.getString(TAG_PIC),
st.getString(TAG_GENDER),
st.getString(TAG_LANG),
st.getString(TAG_ATTRIBUTES),
intent.getIntExtra("sup_id", 0),
intent.getStringExtra("email"),
intent.getStringExtra("password"),
intent.getStringExtra("name"),
intent.getStringExtra("surname"),
intent.getStringExtra("pic"),
intent.getStringExtra("gender"),
intent.getStringExtra("lang"),
"");
PCBcontext.getDevice().insertUser(new_user);
Log.i(this.getClass().getCanonicalName(),"Loading vocabulary for "+new_user.get_name_stu());
final ProgressDialog progressDialog=ProgressDialog.show(getActivity(), getString(R.string.loadingGrammar),
getString(R.string.userLoadingTxt), false, false);
PCBcontext.set_user(new_user, intent.getStringExtra("token"), new iImgDownloaderListener() {
@Override
public void loadComplete() {
progressDialog.dismiss();
Intent pictogramActivity = new Intent(getActivity(), PictogramActivity.class);
startActivity(pictogramActivity);
}
@Override
public void loadImg(Img image) {
}
public void error(Exception e) {
progressDialog.dismiss();
GUITools.show_alert(StudentFragmentGrid.this.getActivity(), R.string.serverError, e.getMessage());
Log.e(this.getClass().getCanonicalName(), "Server error:"+ e.getLocalizedMessage());
}
});
} catch (JSONException e) {
e.printStackTrace();
Log.e(StudentFragmentGrid.this.getClass().getCanonicalName(), e.getMessage());
}
}
private void show_student_list_online() {
final Vector<Img> imgs = new Vector<>(downloaded_students.size());
this.nameStudents=new String[downloaded_students.size()];
this.idStudents=new Vector<>(downloaded_students.size());
this.imageStudents=new Vector<>(downloaded_students.size());
for (int i = 0; i < downloaded_students.size(); i++) {
JSONObject st;
try {
st = downloaded_students.get(i);
Integer st_id = st.getInt(TAG_ID);
String st_name = st.getString(TAG_NAME);
String st_pic = st.getString(TAG_PIC);
nameStudents[i]=st_name;
idStudents.add(st_id);
imgs.add(new Img(st_id,st_pic,Img.STUDENT)); //it's required to download student's images
} catch (JSONException e) {
e.printStackTrace();
Log.e(StudentFragmentGrid.this.getClass().getCanonicalName(), e.getMessage());
}
} //for
final ProgressDialog progressDialog= ProgressDialog.show(getActivity(), getString(R.string.imguserLoadingMsg),
getString(R.string.userLoadingTxt), false, false);
ImgDownloader downloader = new ImgDownloader(getActivity(), new iImgDownloaderListener() {
@Override
public void loadComplete() {
progressDialog.dismiss();
if (downloaded_students.size() > 1) {
for (int i = 0; i < imgs.size(); i++)
try {
imageStudents.add(imgs.get(i).get_bitmap(getActivity().getBaseContext()));
} catch (IOException e) {
e.printStackTrace();
Log.e(StudentFragmentGrid.this.getClass().getCanonicalName(),e.getMessage());
}
}
if (StudentFragmentGrid.super.getView()!=null)
showStudentsGrid();
else
onlineStudentsOK=true;
}
@Override
public void loadImg(Img image) {
}
public void error(Exception e) {
progressDialog.dismiss();
GUITools.show_alert(PCBcontext.getContext(), R.string.serverError, e.getMessage());
Log.e(this.getClass().getCanonicalName(), "Server error:"+ e.getLocalizedMessage());
}
}, ImgDownloader.tsource.remote);
downloader.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, imgs);
}
private void download_students(int sup_id ) {
String token = getActivity().getIntent().getExtras().getString("token");
RestapiWrapper wrapper = new RestapiWrapper(
getActivity().getApplicationContext().getResources().getString(R.string.server), token);
String operation = "sup/" + sup_id + "/students";
final ProgressDialog progressDialog= ProgressDialog.show(getActivity(), getString(R.string.userLoadingTxt),
getString(R.string.userLoadingTxt), false, false);
wrapper.ask(operation, new iRestapiListener() {
@Override
public void error(Exception e) {
Log.e(this.getClass().getName(), " Server restapi error: " + e.getLocalizedMessage());
progressDialog.dismiss();
GUITools.show_alert(getActivity(), R.string.loginErrorTxt, getString(R.string.serverError), new GUITools.iOKListener() {
@Override
public void ok() {
PCBcontext.restart_app();
}
});
}
@Override
public void preExecute() {
}
@Override
public void result(JSONArray students) {
progressDialog.dismiss();
StudentFragmentGrid.this.downloaded_students=new Vector();
for (int i=0;i<students.length();i++) {
JSONObject student;
try {
student = students.getJSONObject(i);
if (student.getInt(TAG_SUPERVISION)>0)
StudentFragmentGrid.this.downloaded_students.add(student);
} catch (JSONException e) {
e.printStackTrace();
}
}
switch (students.length()) {
case 0:
GUITools.show_alert(getActivity(), R.string.loginErrorTxt,getString(R.string.noStudentsError), new GUITools.iOKListener() {
@Override
public void ok() {
PCBcontext.restart_app();
}
});
break;
case 1:
new_user(0);
break;
default:
show_student_list_online();
}
}
@Override
public void result(JSONObject result) {
}
});
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
Intent intent=getActivity().getIntent();
Boolean offline = intent.getBooleanExtra("offline", false);
int sup_id=intent.getIntExtra("sup_id", 0);
if (offline) {
Vector<User> users;
try {
users = PCBcontext.getDevice().recoverStudents(sup_id);
Log.i(this.getClass().getCanonicalName(),"Recovering "+users.size()+" students list for "+ sup_id+" from local DB");
} catch (JSONException e) {
e.printStackTrace();
users=null;
}
int i=0;
this.nameStudents=new String[users.size()];
this.idStudents=new Vector<>(users.size());
this.imageStudents=new Vector<>(users.size());
for (User user: users) {
this.idStudents.add(user.get_id_stu());
this.nameStudents[i++]=user.get_name_stu();
try {
this.imageStudents.add(user.get_bitmap_stu(getActivity().getBaseContext()));
} catch (IOException e) {
e.printStackTrace();
Log.e(this.getClass().getName(), " Getting images error: " + e.getLocalizedMessage());
}
}
}
else
download_students(sup_id);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_new_student, container, false);
gridView = (GridView)view.findViewById(R.id.loginStudentGridView);
Boolean offline = getActivity().getIntent().getBooleanExtra("offline", false);
if (offline || onlineStudentsOK) showStudentsGrid();
return view;
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/gui/TapeAdapter.java deleted 100644 → 0
package com.yottacode.pictogram.gui;
import android.annotation.TargetApi;
import android.os.Build;
import android.os.Bundle;
import android.speech.tts.TextToSpeech;
import android.speech.tts.UtteranceProgressListener;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.FrameLayout;
import android.widget.ImageView;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.PCBcontext;
import java.util.Iterator;
import java.util.LinkedList;
public class TapeAdapter extends BaseAdapter {
//private Context mContext;
private LinkedList<Picto> pictoLinkedList;
public TapeAdapter(){
//mContext = c;
pictoLinkedList = new LinkedList<Picto>(); // the list begins empty
}
@Override
public int getCount(){
return pictoLinkedList.size();
}
public Picto getItem(int position) {
// este método debería devolver el objeto que esta en esa posición del
// adapter.
return pictoLinkedList.get(position);
}
public long getItemId(int position) {
// este método debería devolver el id de fila del item que esta en esa
// posición del adapter. No es necesario en este caso más que devolver 0.
return 0;
}
// AÑADIR ITEM AL ADAPTADOR
public void addItem(Picto p){
pictoLinkedList.add(p);
}
// ELIMINAR ITEM DEL ADAPTADOR
public void deleteItem(int position){
pictoLinkedList.remove(position);
}
// ELIMINAR el último ITEM DEL ADAPTADOR
public void deleteLastView(){
// Controlar excepcion al intentar eliminar el último cuando no hay elementos
try{
pictoLinkedList.removeLast();
}catch(ArrayIndexOutOfBoundsException exception){
Log.e("Excepción", "ArrayIndexOutOfBounds: " + exception.getMessage());
}
}
// ELIMINAR TODOS LOS ITEMS DEL ADAPTADOR
public void deleteAll(){
pictoLinkedList.clear();
}
// DEVUELVE TODOS LOS ELEMENTOS
public LinkedList<Picto> getAll(){ return pictoLinkedList; }
// Devuelvo la cadena actual como un String
public String getAllAsString(){
String complete = "";
Iterator<Picto> iterator = pictoLinkedList.iterator();
while (iterator.hasNext()) {
Picto current = iterator.next();
complete += " " + current.get_translation();
}
return complete;
}
// DEVUELVE último elemento
public Picto getLastItem(){
return pictoLinkedList.getLast();
}
// Devuelve true o false si tiene o no elementos la lista de pictos
public boolean hasElements(){
return (pictoLinkedList.size() > 0);
}
@Override
public View getView(int position, View convertView, ViewGroup parent){
return PictoItemViewGenerator.getPictoView(
this.pictoLinkedList.get(position),
convertView,
parent
);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public void ttsAllNew(TextToSpeech tts) {
String input = getAllAsString();
Bundle params = new Bundle();
params.putString(TextToSpeech.Engine.KEY_PARAM_VOLUME, "1");
params.putString(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, "TAPE_READ");
tts.speak(input, TextToSpeech.QUEUE_FLUSH, params, "TAPE_READ");
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/kiosk/AppContext.java deleted 100644 → 0
package com.yottacode.pictogram.kiosk;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.PowerManager;
/**
* Created by emblanco on 14/10/15.
*/
public class AppContext extends Application {
private AppContext instance;
private PowerManager.WakeLock wakeLock;
private OnScreenOffReceiver onScreenOffReceiver;
@Override
public void onCreate() {
super.onCreate();
instance = this;
registerKioskModeScreenOffReceiver();
startKioskService(); // Service for restarting the app when another app go to foreground
}
private void registerKioskModeScreenOffReceiver() {
// register screen off receiver
final IntentFilter filter = new IntentFilter(Intent.ACTION_SCREEN_OFF);
onScreenOffReceiver = new OnScreenOffReceiver();
registerReceiver(onScreenOffReceiver, filter);
}
public PowerManager.WakeLock getWakeLock() {
if(wakeLock == null) {
// lazy loading: first call, create wakeLock via PowerManager.
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
wakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, "wakeup");
}
return wakeLock;
}
// Service for restarting the app when another app go to foreground
private void startKioskService() {
startService(new Intent(this, KioskService.class));
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/kiosk/BootReceiver.java deleted 100644 → 0
package com.yottacode.pictogram.kiosk;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import com.yottacode.pictogram.gui.MainActivity;
/**
* Created by emblanco on 13/10/15.
*
*
* Recieve event when the device boot and starts MainActivity
*
*
*/
public class BootReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Intent myIntent = new Intent(context, MainActivity.class);
myIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(myIntent);
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/kiosk/KioskService.java deleted 100644 → 0
package com.yottacode.pictogram.kiosk;
import android.app.ActivityManager;
import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.IBinder;
import android.preference.PreferenceManager;
import android.util.Log;
import com.yottacode.pictogram.gui.PictogramActivity;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* Created by emblanco on 15/10/15.
*
* Since Android 4 there is no effective method to deactivate the home button.
* That is the reason why we need to do a little hack.
* In general the idea is to detect when a new application is in foreground and restart
* your activity immediately.
*
* The thread checks every two seconds if the app is running in foreground.
* If not, the thread will immediately recreate your activity.
*
*/
public class KioskService extends Service {
private static final long INTERVAL = TimeUnit.SECONDS.toMillis(2); // periodic interval to check in seconds -> 2 seconds
private static final String TAG = KioskService.class.getSimpleName();
private static final String PREF_KIOSK_MODE = "pref_kiosk_mode";
private Thread t = null;
private Context ctx = null;
private boolean running = false;
@Override
public void onDestroy() {
Log.i(TAG, "Stopping service 'KioskService'");
running =false;
super.onDestroy();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i(TAG, "Starting service 'KioskService'");
running = true;
ctx = this;
// start a thread that periodically checks if your app is in the foreground
t = new Thread(new Runnable() {
@Override
public void run() {
do {
handleKioskMode();
try {
Thread.sleep(INTERVAL);
} catch (InterruptedException e) {
Log.i(TAG, "Thread interrupted: 'KioskService'");
}
}while(running);
stopSelf();
}
});
t.start();
return Service.START_NOT_STICKY;
}
private void handleKioskMode() {
// is Kiosk Mode active?
if(isKioskModeActive(this)) {
// is App in background?
if(isInBackground()) {
restoreApp(); // restore!
}
}
}
private boolean isInBackground() {
ActivityManager am = (ActivityManager) ctx.getSystemService(Context.ACTIVITY_SERVICE);
List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1);
ComponentName componentInfo = taskInfo.get(0).topActivity;
return (!ctx.getApplicationContext().getPackageName().equals(componentInfo.getPackageName()));
}
private void restoreApp() {
// Restart activity
Intent i = new Intent(ctx, PictogramActivity.class);
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
ctx.startActivity(i);
}
public boolean isKioskModeActive(final Context context) {
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
return sp.getBoolean(PREF_KIOSK_MODE, false);
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/kiosk/OnScreenOffReceiver.java deleted 100644 → 0
package com.yottacode.pictogram.kiosk;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.PowerManager;
import android.preference.PreferenceManager;
/**
* Created by emblanco on 14/10/15.
*
*
Short power button press:
It can detect a short button press by handling the ACTION_SCREEN_OFF intent and kick the screen
back to life with acquiring a wake lock.
*
*
*
*/
public class OnScreenOffReceiver extends BroadcastReceiver {
private static final String PREF_KIOSK_MODE = "pref_kiosk_mode";
@Override
public void onReceive(Context context, Intent intent) {
if(Intent.ACTION_SCREEN_OFF.equals(intent.getAction())){
AppContext ctx = (AppContext) context.getApplicationContext();
// is Kiosk Mode active?
if(isKioskModeActive(ctx)) {
wakeUpDevice(ctx);
}
}
}
private void wakeUpDevice(AppContext context) {
PowerManager.WakeLock wakeLock = context.getWakeLock(); // get WakeLock reference via AppContext
if (wakeLock.isHeld()) {
wakeLock.release(); // release old wake lock
}
// create a new wake lock...
wakeLock.acquire();
// ... and release again
wakeLock.release();
}
private boolean isKioskModeActive(final Context context) {
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
return sp.getBoolean(PREF_KIOSK_MODE, false);
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/net/ImgDownloader.java deleted 100644 → 0
package com.yottacode.pictogram.net;
import android.app.ActivityManager;
import android.content.Context;
import android.os.AsyncTask;
import android.util.Log;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.tools.Img;
import com.yottacode.pictogram.tools.PCBcontext;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Vector;
/**
* Image downloader from the server or local for pictograms and student's and supervisor's profile pictures.
* Permissions required in AndroidManifest.xml:
* <uses-permission android:name="android.permission.INTERNET" />
*/
public class ImgDownloader extends AsyncTask<Vector<Img>, Void, Img> {
iImgDownloaderListener imgListener;
public static enum status {downloading, downloaded_ok, downloaded_failed}
public static enum tsource{remote,local}
public status current;
private boolean force_download;
Context context;
ActivityManager.MemoryInfo mi;
ActivityManager activityManager;
tsource source;
public ImgDownloader(Context context, iImgDownloaderListener listener, tsource source) {
this.imgListener = listener;
this.context=context;
this.mi = new ActivityManager.MemoryInfo();
this.activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
this.force_download=context.getResources().getBoolean(R.bool.force_img_download);
this.source=source;
}
@Override
protected void onPreExecute() {
}
protected Img doInBackground( Vector<Img> imgs) {
InputStream is=null;
Log.d(this.getClass().getCanonicalName(), "Required images: " + imgs.size());
this.current= ImgDownloader.status.downloading;
int i=0,j=0,allsize=0;
Long availableMegs = mi.availMem / 1048576L;
int seconds = Calendar.getInstance().get(Calendar.SECOND);
try {
for (Img img: imgs) {
if (!img.exists_bitmap(this.context) || this.force_download) try {
this.activityManager.getMemoryInfo(mi);
if (this.source==source.remote) {
String surl = context.getResources().getString(R.string.server) + "/" + img.get_url();
URL url = new URL(surl);
URLConnection ucon = url.openConnection();
is = ucon.getInputStream();
}else {
File file=new File(img.get_url());
is=new FileInputStream(file);
}
int size=img.save_bitmap(this.context, is);
allsize+=size;
i++;
} catch (IOException e) {
j++;
Log.e(this.getClass().getCanonicalName(), img.get_url() + " was not downloaded: "+e);
} finally {
if (is != null) is.close();
}
}
this.current= status.downloaded_ok;
} catch (IOException e) {
Log.d(this.getClass().getCanonicalName(), "Error: " + e);
this.current= status.downloaded_failed;
}
seconds=Calendar.getInstance().get(Calendar.SECOND)-seconds;
Log.i(this.getClass().getCanonicalName(),
"Images Downloaded: " + i+"/"+imgs.size()+ " (size:"+allsize/1024+" Kbytes)"+
". Cached: "+ (imgs.size()-i)+"/"+imgs.size()+
". Download failed: "+ j+"/"+imgs.size()+
". Memory required:"+((mi.availMem / 1048576L)-availableMegs)+" MB"+
". Used time: "+seconds+" seconds at "+new SimpleDateFormat("HH:mm:ss"));
return imgs.size() > 1 ? null
: imgs.get(0);
}
@Override
protected Img doInBackground(Vector... params) {
doInBackground(params[0]);
return null;
}
@Override
protected void onPostExecute(Img img) {
if (imgListener!=null)
if(img == null) imgListener.loadComplete();
else imgListener.loadImg(img);
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/net/NetService.java deleted 100644 → 0
package com.yottacode.pictogram.net;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.TaskStackBuilder;
import android.content.Intent;
import android.support.v4.app.NotificationCompat;
import android.util.Log;
import com.yottacode.net.RestapiWrapper;
import com.yottacode.net.iRestapiListener;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.dao.LoginException;
import com.yottacode.pictogram.dao.User;
import com.yottacode.pictogram.gui.PictogramActivity;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* Background services to be executed every "delay" seconds. Tasks to be executed:
* If offline mode (there is no server connection):
* - keep local record of actions
* If online mode:
* - reload vocabulary
* - move records into the server of actions and purge the actions pool
* @author Fernando Martinez Santiago
* @version 1.0
*/
public class NetService implements Runnable {
public static final String PREFS_NAME = "MyPrefsFile";
private static NotificationCompat.Builder builder;
static final String ping_session="server/ping";
private boolean updated;
public NetService(int delay) {
this.updated=RestapiWrapper.ping(PCBcontext.getContext().getResources().getString(R.string.server), ping_session);
this.builder = new NotificationCompat.Builder(PCBcontext.getContext());
Intent resultIntent = new Intent(PCBcontext.getContext(), PictogramActivity.class);
TaskStackBuilder stackBuilder = TaskStackBuilder.create(PCBcontext.getContext());
stackBuilder.addParentStack(PictogramActivity.class);
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent =
stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
builder.setContentIntent(resultPendingIntent);
Log.i(this.getClass().getName(), "Checking Pictogram server access...");
Log.i(this.getClass().getName(), this.updated ? "Pictogram server access ok" : "Pictogram server access failed, Internet connection available?");
ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);
exec.scheduleWithFixedDelay(this, 0, delay, TimeUnit.SECONDS);
}
public void login() {
User user=PCBcontext.getPcbdb().getCurrentUser();
if (user.is_supervisor())
ServerLogin.login_supervisor(user.get_email_sup(), user.get_pwd_sup(), new iRestapiListener() {
@Override
public void preExecute() {
}
@Override
public void result(JSONArray result) {
PCBcontext.getPcbdb().user_online(true);
}
@Override
public void result(JSONObject result) {
}
@Override
public void error(Exception e) {
Log.e(this.getClass().getSimpleName(), "Error un when server login:" + e.getMessage());
if (e instanceof LoginException) PCBcontext.restart_app();
}
});
else ServerLogin.login_student(user.get_nickname_stu(), user.get_pwd_stu(), new iRestapiListener() {
@Override
public void preExecute() {
}
@Override
public void result(JSONArray result) {
PCBcontext.getPcbdb().user_online(true);
}
@Override
public void result(JSONObject result) {
}
@Override
public void error(Exception e) {
Log.e(this.getClass().getSimpleName(),"Error un when server login:"+e.getMessage());
if (e instanceof LoginException) PCBcontext.restart_app();;
}
});
}
public boolean online() {return updated;}
/**
* ping to the server by using a restapi call. If ok, the call will return the empty set
*/
@Override
public void run() {
PCBcontext.getRestapiWrapper().ask(ping_session, new iRestapiListener() {
@Override
public void preExecute() {
}
@Override
public void result(JSONArray result) {
}
@Override
public void result(JSONObject result) {
if (!updated) {
updated = true;
if (PCBcontext.is_user_logged()) //si el usuario aun no hizo login, en realidad no es necesario hacer nada
// Comprobar si hay usuario offline, para hacer login transparente
if (PCBcontext.is_user_offline()){
login();
} else if (PCBcontext.is_user_online()){
Log.i(this.getClass().getName(), "PCB reconnect");
PCBcontext.getRoom().reconnect();
PCBcontext.getVocabulary().synchronize();
PCBcontext.getActionLog().batch();
}
}
Log.i(this.getClass().getName(), "PCB status checked. Updated? " + updated);
notifyStatus();
}
@Override
public void error(Exception e) {
updated = false;
Log.i(this.getClass().getName(), "PCB offline because exception happens: " + e.getMessage());
notifyStatus();
}
});
}
public void notifyStatus() {
int notifyID = 1;
String user="";
if (PCBcontext.getPcbdb()!=null) {
user=PCBcontext.getPcbdb().getCurrentUser().get_name_stu();
if (PCBcontext.getPcbdb().getCurrentUser().is_supervisor())
user += " (" + PCBcontext.getPcbdb().getCurrentUser().get_name_sup() + ")";
}
if (updated)
builder.setSmallIcon(R.drawable.application_online)
.setContentTitle(PCBcontext.getContext().getResources().getString(R.string.pictogram_online))
.setContentText(user);
else
builder.setSmallIcon(R.drawable.application_offline)
.setContentTitle(PCBcontext.getContext().getResources().getString(R.string.pictogram_offline))
.setContentText(user);
NotificationManager mNotificationManager =
(NotificationManager) PCBcontext.getContext().getSystemService(PCBcontext.getContext().NOTIFICATION_SERVICE);
mNotificationManager.notify(notifyID, builder.build());
}
public void closeNotifyStatus(){
int notifyID = 1;
NotificationManager mNotificationManager =
(NotificationManager) PCBcontext.getContext().getSystemService(PCBcontext.getContext().NOTIFICATION_SERVICE);
mNotificationManager.cancel(notifyID);
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/net/PictoUploader.java deleted 100644 → 0
package com.yottacode.pictogram.net;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import com.google.gson.JsonObject;
import com.koushikdutta.ion.Ion;
import com.koushikdutta.ion.Response;
import com.yottacode.net.iRestapiListener;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.action.VocabularyAction;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.Img;
import com.yottacode.pictogram.tools.PCBcontext;
import com.yottacode.tools.BitmapTools;
import com.yottacode.tools.GUITools;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Hashtable;
import java.util.concurrent.ExecutionException;
/**
* Created by Fernando on 02/03/2016.
*/
public class PictoUploader {
Picto picto=null;
public PictoUploader(Picto picto) {
this.picto=picto;
}
private int uploadImg( Img img) throws UnsupportedEncodingException {
int img_id;
Bitmap bmp=null;
if (!img.get_filetype().equalsIgnoreCase("png"))
throw new UnsupportedEncodingException("Extension "+img.get_filetype()+" is not supported. Only png files");
Ion ion = Ion.getDefault(PCBcontext.getContext());
try {
bmp=img.get_bitmap(PCBcontext.getContext());
} catch (IOException e) {
Log.e(Img.class.getCanonicalName(), "Error when decoding "+img.file_name());
}
Log.i(this.getClass().getCanonicalName(), "Uploading Picto img " + img.file_name() + " from " + img.get_type() + "- Size:" + bmp.getWidth() + " " + bmp.getHeight());
File file = img.file(PCBcontext.getContext());
Response<JsonObject> response=null;
try {
response=ion.with(PCBcontext.getContext())
.load("POST", PCBcontext.getContext().getResources().getString(R.string.server) + "/picto/upload")
.setMultipartParameter("filename", Integer.toString(img.get_id()))
.setMultipartParameter("extension", img.get_filetype())
.setMultipartParameter("owner", Integer.toString(PCBcontext.getPcbdb().getCurrentUser().get_id_sup()))
.setMultipartParameter("folder", "custompictos")
.setMultipartParameter("source", "2")
.setMultipartParameter("token", PCBcontext.getRestapiWrapper().getToken())
.setMultipartFile("file", "image/png", file)
.asJsonObject()
.withResponse().get();
if (response != null && response.getHeaders().code() == 200) {
Log.i(this.getClass().getCanonicalName(), "Uploaded image result: " + response.getHeaders() + ":" + response.getResult());
img_id=response.getResult().get("id").getAsInt();
} else {
img_id=-1;
Log.i(this.getClass().getCanonicalName(), "Uploaded image failed ");
if (response != null)
Log.i(this.getClass().getCanonicalName(), "Uploaded image failed, headers: " + response.getHeaders());
}
} catch (InterruptedException e) {
Log.e(this.getClass().getCanonicalName(), "Image upload error: " + e.getMessage()+ "Code: "+
(response == null ? -1 : response.getHeaders().code()));
img_id=-1;
} catch (ExecutionException e) {
Log.e(this.getClass().getCanonicalName(), "Image upload error: " + e.getMessage()+
(response == null ? -1 : response.getHeaders().code()));
img_id=-1;
}
// ion.dump();
return img_id;
}
/**
* if a picto was included from the PCB, the translation is uploaded to the server
*/
private void uploadAttributes(int id_picto, final iPictoUploaderListener listener) {
Hashtable<String, String> params = new Hashtable<String, String>(4);
try {
JSONObject json_attrs =new JSONObject().put("status",picto.get_status());
if (PCBcontext.getPcbdb().getCurrentUser().has_categories())
json_attrs.put(Picto.JSON_ATTTRS.CATEGORY, picto.get_category())
.put(Picto.JSON_ATTTRS.COLUMN, picto.get_column())
.put(Picto.JSON_ATTTRS.ROW, picto.get_row());
else
json_attrs.put(Picto.JSON_ATTTRS.CATEGORY, picto.NO_CATEGORY)
.put(Picto.JSON_ATTTRS.FREE_COLUMN, picto.getFreeColumn())
.put(Picto.JSON_ATTTRS.FREE_ROW, picto.getFreeRow());
params.put("json", new JSONObject().put("attributes",json_attrs).toString());
} catch (JSONException e) {
e.printStackTrace();
Log.e(this.getClass().getCanonicalName(), " Error: " + e.getLocalizedMessage());
}
PCBcontext.getRestapiWrapper().ask(PCBcontext.getPcbdb().getCurrentUser().get_restapi_operation_stu() + "/picto/"+id_picto, params, "post", true, new iRestapiListener() {
@Override
public void preExecute() {
}
@Override
public void result(JSONArray result) {
}
@Override
public void result(JSONObject result) {
Log.i(this.getClass().getCanonicalName(), " Attributes uploaded: " + result.toString());
listener.success(true);
}
@Override
public void error(Exception e) {
Log.e(this.getClass().getCanonicalName(), " Error uploading attributes: " + e.getLocalizedMessage());
listener.success(false);
}
});
}
/**
* if the a picto was included from the PCB, the translation is uploaded to the server
*/
private void uploadTranslation( int id_picto, final iPictoUploaderListener listener) {
final Hashtable<String, String> params = new Hashtable<String, String>(3);
params.put("picto", Integer.toString(id_picto));
params.put("lang", PCBcontext.getPcbdb().getCurrentUser().get_lang_stu());
params.put("text", picto.get_translation());
PCBcontext.getRestapiWrapper().ask("picto/exp", params, "post", new iRestapiListener() {
@Override
public void preExecute() {
}
@Override
public void result(JSONArray result) {
}
@Override
public void result(JSONObject result) {
Log.i(this.getClass().getCanonicalName(), "Uploaded translation result: " + result.toString());
listener.success(true);
}
@Override
public void error(Exception e) {
Log.e(this.getClass().getCanonicalName(), "Error uploading translation: " + e.getLocalizedMessage()+" Picto:"+params.get("picto")+" Lang:"+params.get("lang")+" Text:"+params.get("text"));
listener.success(false);
}
});
}
/**
*Try to Upload local picto. It requires:
* i) to upload the image,
* ii) to upload the attributes
* iii) to upload the expression
*
**/
public void upload(final Context context) throws IOException {
final int local_img_id = this.picto.get_id();
final int img_id = uploadImg(this.picto);
iPictoUploaderListener listener = new iPictoUploaderListener() {
int elements_uploaded = 0;
@Override
public void success(boolean success) {
if (success) elements_uploaded++;
else
GUITools.show_alert(context, R.string.upload_error,PictoUploader.this.picto.get_translation());
if (elements_uploaded == 2) {
PCBcontext.getPcbdb().deletePicto(local_img_id);
PictoUploader.this.picto.delete_bitmap(PCBcontext.getContext());
PictoUploader.this.picto.update_id(img_id);
PCBcontext.getRoom().emit(new VocabularyAction(VocabularyAction.ADD, PictoUploader.this.picto));
GUITools.show_alert(context, R.string.upload_ok,PictoUploader.this.picto.get_translation()+":"+PictoUploader.this.picto.get_id());
}
}
};
if (img_id > 0) {
uploadAttributes(img_id, listener);
uploadTranslation(img_id, listener);
}
else {
GUITools.show_alert(context, R.string.upload_error, PictoUploader.this.picto.get_translation());
}
}
/**
* if the status of a given picto was modifed from the PCB it is uploaded to the server
*
*/
public void uploadState( ){
Hashtable<String, String> params = new Hashtable<String, String>(1);
params.put("attributes", picto.get_json_server_attrs());
params.put("id_stu", Integer.toString(PCBcontext.getPcbdb().getCurrentUser().get_id_stu()));
params.put("id_pic", Integer.toString(this.picto.get_id()));
Log.i(this.getClass().getCanonicalName(), "Picto Uploading " + params.toString());
PCBcontext.getRestapiWrapper().ask(
PCBcontext.getPcbdb().getCurrentUser().get_restapi_operation_stu() + "/picto",
params, "put", new iRestapiListener() {
@Override
public void preExecute() {
}
@Override
public void result(JSONArray result) {
}
@Override
public void result(JSONObject result) {
Log.i(PictoUploader.this.getClass().getCanonicalName(), "Upload ok Picto " + PictoUploader.this.picto.get_id());
picto.set_local_status(false);
PCBcontext.getRoom().emit(new VocabularyAction(VocabularyAction.ALTERATTRS,PictoUploader.this.picto));
}
@Override
public void error(Exception e) {
Log.e(this.getClass().getCanonicalName(), "Picto Error: " + e.getLocalizedMessage());
}
}
);
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/net/ServerLogin.java deleted 100644 → 0
package com.yottacode.pictogram.net;
import android.util.Log;
import com.yottacode.net.RestapiWrapper;
import com.yottacode.net.iRestapiListener;
import com.yottacode.pictogram.dao.LoginException;
import com.yottacode.pictogram.tools.PCBcontext;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.Hashtable;
/**
* Created by Fernando on 01/04/2016.
*/
public class ServerLogin {
public static void login_student(String username, String password, iRestapiListener listener) {
login("stu/login", null, username, password, listener);
}
public static void login_supervisor(String email, String password, iRestapiListener listener) {
login("sup/login", email, null, password, listener);
}
private static void login(String operation, String email, String username, String password, final iRestapiListener listener){
Hashtable<String, String> postDataParams = new Hashtable<String, String>();
if (email!=null) postDataParams.put("email", email);
if (username!=null) postDataParams.put("username", username);
postDataParams.put("password", password);
PCBcontext.getRestapiWrapper().ask(operation, postDataParams, "post", new iRestapiListener() {
@Override
public void preExecute() {
listener.preExecute();
}
@Override
public void result(JSONArray result) {
listener.result(result);
}
@Override
public void result(JSONObject result) {
try {
if (PCBcontext.is_user_offline()) {
final String TAG_TOKEN="token";
PCBcontext.getPcbdb().user_online(true);
PCBcontext.getRestapiWrapper().setToken(result.getString(TAG_TOKEN));
PCBcontext.getVocabulary().synchronize();
}
listener.result(result);
} catch (JSONException e) {
listener.error(e);
}
}
@Override
public void error(Exception e) {
listener.error(new LoginException(e.getMessage(),e.getMessage().contains("User without students")
? LoginException.NO_STUDENTS
: e.getMessage().contains("failed to connect")
? LoginException.TIME_OUT
: LoginException.BAD_LOGIN));
}
});
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/net/iImgDownloaderListener.java deleted 100644 → 0
package com.yottacode.pictogram.net;
import com.yottacode.pictogram.dao.Picto;
import com.yottacode.pictogram.tools.Img;
import java.util.LinkedList;
/**
* Created by emblanco on 24/09/15.
* MOdified by dofer on 27/06/16.
*/
public interface iImgDownloaderListener {
public void loadComplete(); // for loading the vocabulary
public void loadImg(Img image); // for loading one image
public void error(Exception err); //error happens
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/net/iPictoUploaderListener.java deleted 100644 → 0
package com.yottacode.pictogram.net;
/**
* Created by Fernando on 28/07/2016.
*/
public interface iPictoUploaderListener {
void success(boolean success);
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/tools/FilteredImage.java deleted 100644 → 0
package com.yottacode.pictogram.tools;
/**
* Created by miguelangelgarciacumbreras on 25/7/15.
*/
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.util.Log;
/**
* Image with support for filtering.
*/
public class FilteredImage {
private Bitmap image, mutableBitmap;
private int width;
private int height;
private Bitmap.Config config;
private int[] colorArray;
/**
* Constructor.
*
* @param img the original image
*/
public FilteredImage(Bitmap img) {
this.image = img;
width = img.getWidth();
height = img.getHeight();
config = img.getConfig();
colorArray = new int[width * height];
image.getPixels(colorArray, 0, width, 0, 0, width, height);
mutableBitmap = image.copy(Bitmap.Config.ARGB_8888, true);
applyHighlightFilter();
//addBorder(5, Color.RED);
}
/**
* Get the color for a specified pixel.
*
* @param x x
* @param y y
* @return color
*/
public int getPixelColor(int x, int y) {
return colorArray[y * width + x];
}
/**
* Gets the image.
*
* @return Returns the image.
*/
public Bitmap getImage() {
return mutableBitmap;
}
/**
* Applies highlight filter to the image.
*/
private void applyHighlightFilter() {
int a;
int r;
int g;
int b;
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
int c = getPixelColor(x, y);
a = Color.alpha(c);
r = Color.red(c);
g = Color.green(c);
b = Color.blue(c);
r = (int) (r * 0.4);
g = (int) (g * 0.4);
b = (int) (b * 1.6);
if (r > 255) {
r = 255;
}
if (r < 0) {
r = 0;
}
if (g > 255) {
g = 255;
}
if (g < 0) {
g = 0;
}
if (b > 255) {
b = 255;
}
if (b < 0) {
b = 0;
}
int resultColor = Color.argb(a, r, g, b);
//Log.e("applyHighlightFilter", "x:" + x + "/y:" + y + "/resultColor:" + resultColor);
mutableBitmap.setPixel(x, y, resultColor);
}
}
}
private void addBorder(int borderSize, int color) {
mutableBitmap = Bitmap.createBitmap(this.width + borderSize * 2, this.height + borderSize * 2, this.config);
Canvas canvas = new Canvas(mutableBitmap);
canvas.drawColor(color);
canvas.drawBitmap(image, borderSize, borderSize, null);
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/pictogram/tools/Img.java deleted 100644 → 0
package com.yottacode.pictogram.tools;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.util.Log;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import com.yottacode.tools.FileTools;
import com.yottacode.tools.BitmapTools;
/**
* Img
* @author Fernando
*/
public class Img {
static public String VOCABULARY="vocabulary";
static public String STUDENT="student";
static public String SUPERVISOR="supervisor";
static public float MAX_WIDTH=100;
public static final void mkDirs(Context context) {
File file;
file = new File(path(context, Img.VOCABULARY));
FileTools.deleteDirectory(file);
file.mkdirs();
file = new File(path(context, Img.STUDENT));
FileTools.deleteDirectory(file);
file.mkdirs();
file = new File(path(context, Img.SUPERVISOR));
FileTools.deleteDirectory(file);
file.mkdirs();
}
protected int id;
protected String url;
String type;
final static String FILETYPE="png";
Bitmap bitmap;
/**
*
* @param id
* @param url
* @param type is Vocabulary, Student or Supervisor
*/
public Img(int id, String url, String type) {
this.id = id;
this.url = url;
this.type=type;
this.bitmap=null;
}
public String file_name() { return this.id+"."+Img.FILETYPE; }
public int get_id() { return this.id;}
public String get_url() { return this.url;}
public void set_url(String url) {this.url=url;}
public String get_type() { return this.type;}
public String get_filetype() { return Img.FILETYPE;}
/**
* Load if necessary the bitmap from disk, and it is returned. IIf it is not available, return null
* @param context
* @return the bitmap
* @throws FileNotFoundException
*/
public Bitmap get_bitmap(Context context) throws IOException {
if (this.bitmap==null) {
File file = file(context);
if (file.exists()) {
FileInputStream is = new FileInputStream(file);
this.bitmap = BitmapFactory.decodeStream(is);
is.close();
}
}
return this.bitmap;
}
/**
* Delete the bitmap from disk
* @param context
*/
public void delete_bitmap(Context context) {
File file = file(context);
file.delete();
}
/**
*
* @param context
* @return true if the bitmap is locally stored
*/
public boolean exists_bitmap(Context context) {
return file(context).exists();
}
public static String path(Context context, String type) {
String path = context.getFilesDir()+File.separator +"pictures" + File.separatorChar + type + File.separatorChar;
return path;
}
/**
* The local file where the img is saved. It depends on the image type
* @param context
* @return
*/
public File file(Context context) {
String path=path(context, this.type);
return new File(path, file_name());
}
/**
* Save an image in disk
* @param context
* @param is the stream where the image is available
* @throws IOException
*/
public int save_bitmap(Context context, InputStream is) throws IOException {
File file = file(context);
FileOutputStream os = new FileOutputStream(file);
try {
this.bitmap=BitmapFactory.decodeStream(is);
if (this.bitmap.getWidth()>MAX_WIDTH) {
this.bitmap = new BitmapTools(this.bitmap)
.rescale(MAX_WIDTH / (float) this.bitmap.getWidth())
.get();
}
}catch(java.lang.OutOfMemoryError err) {
Log.e(Img.class.getCanonicalName(), "Out of memory when decoding "+this.get_url());
}
ByteArrayOutputStream outstream = new ByteArrayOutputStream();
this.bitmap.setHasAlpha(true);
this.bitmap.compress(Bitmap.CompressFormat.PNG, 50, outstream);
byte[] byteArray = outstream.toByteArray();
os.write(byteArray);
outstream.close();
os.close();
System.gc();
return byteArray.length;
}
/**
*
* @overide
* Two img are equals whenever they have the same id and type
*/
public boolean equals(Object o) {
return ((Img)o).id==this.id && ((Img)o).type.equals(this.type);
}
/**
* @overide
*/
public String toString() {return this.type+"."+this.id;}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/tools/PCBcontext.java deleted 100644 → 0
package com.yottacode.pictogram.tools;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
import com.yottacode.net.RestapiWrapper;
import com.yottacode.net.SSLDummyContext;
import com.yottacode.pictogram.R;
import com.yottacode.pictogram.action.ActionLog;
import com.yottacode.pictogram.dao.Device;
import com.yottacode.pictogram.dao.PCBDBHelper;
import com.yottacode.pictogram.dao.User;
import com.yottacode.pictogram.grammar.Vocabulary;
import com.yottacode.pictogram.gui.SerialActivity;
import com.yottacode.pictogram.net.NetService;
import com.yottacode.pictogram.action.Room;
import com.yottacode.pictogram.net.iImgDownloaderListener;
public final class PCBcontext {
private static Context context;
private static PCBDBHelper pcbdb;
private static Device device=null;
private static NetService service;
private static Room room;
private static RestapiWrapper wrapper;
private static Vocabulary vocabulary;
private static ActionLog actionLog;
private static boolean init=false;
/**
* Init method for passing params to the singleton
* @param c @TODO application or activity context?
*/
public static void init(Context c){
if (!init) {
init = true;
context = c;
device = new Device(c, null, 1);
SSLDummyContext.init(context.getResources().getBoolean(R.bool.ssl_connect));
wrapper = new RestapiWrapper(context.getResources().getString(R.string.server), null);
service = new NetService(context.getResources().getInteger(R.integer.netservice_timing));
device.deleteDeprecatedImgs();
Log.i(PCBcontext.class.getCanonicalName(), "PCB context started. It's required" +
"set_user method call");
} else {
Log.e(PCBcontext.class.getClass().getCanonicalName(), "Init method was previously" +
"invoked! Please, check your code");
}
}
/**
* @param student
* @param listener
*/
public static void set_user(User student, String token, iImgDownloaderListener listener) {
if (!init) {
throw new java.lang.AssertionError("init must be called once previously ");
}
Log.i(PCBcontext.class.getCanonicalName(), "User set at student " + student.get_name_stu());
wrapper.setToken(token);
pcbdb = new PCBDBHelper(null, 1, student);
pcbdb.user_online(token!=null);
room = new Room();
actionLog = new ActionLog();
vocabulary = new Vocabulary(listener);
getNetService().notifyStatus();
}
/**
*
* @return true if a given user has been logged into the system (the login window was successfully filled)
*/
public static boolean is_user_logged() {
return (init && pcbdb!=null);
}
/**
*
*/
public static void unset_user() {
pcbdb = null;
room = null;
vocabulary = null;
getNetService().notifyStatus();
}
/**
* if the user becomes from offline to online and the login is failed, then the user relogin in
* the app. The most frequent reason is a password change while the user have been logged
* offline
*/
public static void restart_app() {
SerialActivity.resetDefaultUser();
Intent serialActivity = new Intent(PCBcontext.getContext(), SerialActivity.class);
serialActivity.putExtra("resetPrevUser", true);
PCBcontext.getContext().startActivity(serialActivity);
}
/**
* @return true if the user is logged offline and it has not been online previously. False in
* other case (user not logged, user logged online, user offline but it was previously online
* logged
*/
public static boolean is_user_offline() {
if (pcbdb == null) {
return false;
} else {
return !getPcbdb().isUser_online();
}
}
public static boolean is_user_online() {
return pcbdb != null && getPcbdb().isUser_online();
}
/**
* @return context
* @TODO complete documentation
*/
public static Context getContext() {
if (context == null) {
throw new java.lang.NullPointerException("Context is null. PCBcontext.init must be" +
"invoked previously");
}
return context;
}
/**
* @return device
* @TODO complete documentation
*/
public static Device getDevice() {
if (device == null) {
throw new java.lang.NullPointerException("Device is null. PCBcontext.init must be" +
"invoked previously");
}
return device;
}
/**
* @return PCBDB
* @TODO complete documentation
*/
public static PCBDBHelper getPcbdb() {
if (context == null) {
throw new java.lang.NullPointerException("PCBDB is null. PCBcontext.set_user must be" +
"invoked previously");
}
return pcbdb;
}
/**
* @return NetService
* @TODO complete documentation
*/
public static NetService getNetService(){
if (service == null) {
throw new java.lang.NullPointerException("NetService is null. PCBcontext.set_user" +
"must be invoked previously");
}
return service;
}
/**
* @return RestapiWrapper
* @TODO complete documentation
*/
public static RestapiWrapper getRestapiWrapper(){
if (wrapper == null) {
throw new java.lang.NullPointerException("RestapiWrapper is null. PCBcontext.init" +
"must be invoked previously");
}
return wrapper;
}
/**
* @return Room
* @TODO complete documentation
*/
public static Room getRoom(){
if (room == null) {
throw new java.lang.NullPointerException("Room is null. PCBcontext.set_user must" +
"be invoked previously");
}
return room;
}
/**
* @return Vocabulary
* @TODO complete documentation
*/
public static Vocabulary getVocabulary(){
if (vocabulary == null) {
throw new java.lang.NullPointerException("Vocabulary is null. PCBcontext.set_user" +
"must be invoked previously");
}
return vocabulary;
}
/**
* @return ActionLog
* @TODO complete documentation
*/
public static ActionLog getActionLog(){
if (actionLog == null) {
throw new java.lang.NullPointerException("ActionLog is null. PCBcontext.set_user" +
"must be invoked previously");
}
return actionLog;
}
}
android/Pictogram/app/src/main/java/com/yottacode/pictogram/tts/TTSHelper.java deleted 100644 → 0
package com.yottacode.pictogram.tts;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import android.annotation.TargetApi;
import android.os.Build;
import android.speech.tts.TextToSpeech;
import android.content.Context;
import android.speech.tts.Voice;
import android.util.Log;
import android.widget.ArrayAdapter;
/**
* PCB TTS service
* @author Fernando Martinez Santiago
* @version 1.0
*/
public class TTSHelper {
TextToSpeech ttobj;
public boolean engine_ok;
public boolean voice_ok=true;
Voice voice;
public void createTTS(Context context, String engine) {
this.destroy();
/* this.ttobj = new TextToSpeech(
context,
new TextToSpeech.OnInitListener() {
@Override
public void onInit(int status) {
if (status != TextToSpeech.ERROR) {
ttobj.setLanguage(Locale.getDefault());
}
}
}, engine);*/
this.engine_ok=true;
Log.e(context.getApplicationInfo().processName,"TTS engine "+engine+" loaded");
}
public TTSHelper(Context context) {
createTTS(context ,null);
}
public TTSHelper(Context context, String engine) {
try {
createTTS(context ,engine);
}catch (Exception e) {
createTTS(context ,null);
Log.e(context.getApplicationInfo().processName, "Engine "+engine+" error",e);
this.engine_ok=false;
}
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public void setVoice(Context context, String voice) {
try {
Set<Voice> voices = this.ttobj.getVoices();
if (voices!=null)
for (Voice avoice : voices) {
Log.e(context.getApplicationInfo().processName,"Voice name "+avoice.getName());
if (avoice.getName().compareTo(voice) == 0) {
this.ttobj.setVoice(avoice);
this.voice_ok=true;
Log.e(context.getApplicationInfo().processName,"Voice "+voice+" loaded");
break;
}
}
else
Log.e(context.getApplicationInfo().processName,"Voice "+voice+" is not available");
}catch(Exception e) {
Log.e(context.getApplicationInfo().processName,"Voice "+voice+" error",e);
this.voice_ok=false;
}
}
public boolean isVoice_ok() { return this.voice_ok;}
public boolean isEngine_ok() { return this.engine_ok;}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public void speakText(String toSpeak){
this.ttobj.speak(toSpeak, TextToSpeech.QUEUE_FLUSH,null, toSpeak.hashCode()+"");
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public void show(ArrayAdapter mArrayAdapter) {
String tts_info[] = new String[25];
int i=0;
List<TextToSpeech.EngineInfo> engines = this.ttobj.getEngines();
for (Iterator<TextToSpeech.EngineInfo> iter = engines.iterator(); iter.hasNext(); ) {
TextToSpeech.EngineInfo element = iter.next();
Log.i("TTSHelper","TTS: "+element.name + " label:"+element.label);
mArrayAdapter.add("TTS: "+element.name + " label:"+element.label);
}
if (this.ttobj.getVoice()!=null) {
Log.i("TTSHelper", "Default voice:" + this.ttobj.getDefaultVoice().getName());
mArrayAdapter.add("Current voice:" + this.ttobj.getVoice().getName());
Set<Voice> voices = this.ttobj.getVoices();
if (voices != null)
for (Voice voice : voices) {
Log.i("TTSHelper", "Voice: " + voice.getName() + " locale:" + voice.getLocale());
mArrayAdapter.add("Voice: " + voice.getName() + " locale:" + voice.getLocale());
}
}
}
public void destroy() {
if(ttobj !=null){
ttobj.stop();
ttobj.shutdown();
}
this.ttobj=null;
}
}
\ No newline at end of file
android/Pictogram/app/src/main/java/com/yottacode/tools/BitmapTools.java deleted 100644 → 0
package com.yottacode.tools;
import android.graphics.Bitmap;
import android.graphics.Matrix;
/**
* Created by Fernando on 15/03/2016.
*/
public class BitmapTools {
Bitmap bitmap;
public BitmapTools(Bitmap bitmap) { this.bitmap=bitmap;}
public Bitmap get() {return this.bitmap;}
public BitmapTools resize(int w, int h) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
int newWidth = w;
int newHeight = h;
// calculamos el escalado de la imagen destino
float scaleWidth = ((float) newWidth) / width;
float scaleHeight = ((float) newHeight) / height;
// para poder manipular la imagen
// debemos crear una matriz
Matrix matrix = new Matrix();
// resize the Bitmap
matrix.postScale(scaleWidth, scaleHeight);
// volvemos a crear la imagen con los nuevos valores
Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0,
width, height, matrix, true);
this.bitmap=resizedBitmap;
return this;
}
public BitmapTools rescale(float scale) {
int width = (int) (scale * (float) this.bitmap.getWidth());
int height = (int) (scale * (float) this.bitmap.getHeight());
return resize(width,height);
}
public BitmapTools paintSquare(int thickness, int color ) {
for (int i = 0; i < this.bitmap.getWidth(); i++)
for (int t = 1; t <= thickness; t++) {
this.bitmap.setPixel(i, 0 + t-1, color);
this.bitmap.setPixel(i, this.bitmap.getHeight() - t, color);
}
for (int i = 0; i < this.bitmap.getHeight(); i++)
for (int t = 1; t <= thickness; t++) {
this.bitmap.setPixel(0 + t-1, i, color);
this.bitmap.setPixel(this.bitmap.getWidth() - t, i, color);
}
return this;
}
}
android/Pictogram/app/src/main/java/com/yottacode/tools/FileTools.java deleted 100644 → 0
package com.yottacode.tools;
import java.io.File;
/**
* Created by Fernando on 14/03/2016.
*/
public class FileTools {
public static boolean deleteDirectory(File path) {
if( path.exists() ) {
File[] files = path.listFiles();
if (files == null) {
return true;
}
for(int i=0; i<files.length; i++) {
if(files[i].isDirectory()) {
deleteDirectory(files[i]);
}
else {
files[i].delete();
}
}
}
return( path.delete() );
}
}
android/Pictogram/app/src/main/java/com/yottacode/tools/GUITools.java deleted 100644 → 0
package com.yottacode.tools;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.util.Log;
/**
* Created by Fernando on 01/04/2016.
*/
public class GUITools {
public interface iOKListener {
public void ok();
}
public static void show_alert(Context context, int resource_msg, String additional_msg, final iOKListener oklistener) {
AlertDialog.Builder builder = new AlertDialog.Builder(context);
String msg = context.getString(resource_msg);
if (additional_msg != null) msg += ": " + additional_msg;
Log.i(GUITools.class.getName(), "Alert:" + msg);
builder.setMessage(msg)
.setCancelable(false)
.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
if (oklistener != null) oklistener.ok();
}
});
AlertDialog alert = builder.create();
alert.show();
}
public static void show_alert(Context context, int resource_msg) {
show_alert(context, resource_msg, null);
}
public static void show_alert(Context context, int resource_msg, String additional_msg) {
show_alert(context, resource_msg, additional_msg,null);
}
}
android/Pictogram/build.gradle
......@@ -5,7 +5,7 @@ buildscript {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.1.2'
classpath 'com.android.tools.build:gradle:2.1.3'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
......
android/Pictogram/gradle/wrapper/gradle-wrapper.properties
#Mon Jun 06 22:38:39 CEST 2016
#Mon Aug 29 01:05:09 CEST 2016
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip
android/Pictogram/tablet/build.gradle
......@@ -22,7 +22,7 @@ android {
resValue "string", "server", "https://127.0.0.1:9944"
}
LocalFlavor {
resValue "string", "server", "https://192.168.1.37:1337"
resValue "string", "server", "https://192.168.1.36:1337"
}
DevFlavor {
resValue "string", "server", "https://dev.yottacode.com"
......
sails/roles/database/files/pictodb-schema.sql
......@@ -368,7 +368,7 @@ CREATE TABLE IF NOT EXISTS `try` (
`id_ws` int(11) NOT NULL,
`begin` timestamp(3) DEFAULT CURRENT_TIMESTAMP(3),
`end` timestamp(3) NULL,
`result` varchar(20) COLLATE utf8_unicode_ci DEFAULT NULL,
`result` varchar(20) COLLATE utf8_unicode_ci DEFAULT NULL CHECK (result IN ('SUCCESS','SPONTANEUS SUCCESS', 'SUPERVISED SUCCESS', 'FAIL','DISCARDED','MODEL')),
`description` varchar(4096) COLLATE utf8_unicode_ci DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `id_ws` (`id_ws`)
......
sails/roles/database/files/triggers-sessions-integrity-constraints.sql
......@@ -128,7 +128,7 @@ END;;
-- Integrity rule 2: when a session is closed, last try must be discharged
-- when: state COM, event a4
-- current is to NULL (integrity rule 6)
-- current is set NULL (integrity rule 6)
--
DROP TRIGGER IF EXISTS TRG_SESSION_CLOSED;
CREATE TRIGGER TRG_SESSION_CLOSED
......@@ -181,7 +181,7 @@ END;;
-- when: state COM, event a4
-- Integrity rule 5: when a session is continued after a pause and new try is created
-- when: state PAU, event a3
-- Integrity rule 4: when a session is paused, last try must be discharged
-- Integrity rule 4: when a session is paused, last try must be saved as not valid
-- when: state SES, event a3
DROP TRIGGER IF EXISTS TRG_NEW_EVENT;
CREATE TRIGGER TRG_NEW_EVENT
......@@ -219,7 +219,7 @@ thisTrigger: BEGIN
WHERE
id_stu = NEW.id_stu;
IF (idopentry IS NOT NULL) THEN
call deleteOpenTry(idws);
UPDATE try set end=NOW(), result='DISCARDED' where id=idopentry;
END IF;
WHEN 'resumesession' THEN
SELECT id_ws, id_opentry INTO idws, idopentry
......
sails/src/api/controllers/InstructionController.js
......@@ -113,11 +113,10 @@ module.exports = {
*/
destroy: function (req, res) {
Instruction.destroy({ id: req.params.id }).exec(function (error) {
if (error) {
res.badRequest();
throw error;
}
res.ok();
if (error)
return res.badRequest();
else
return res.ok();
});
},
......
sails/src/api/controllers/MethodController.js
......@@ -35,84 +35,65 @@ module.exports = {
create: function(req, res) {
var params = req.allParams();
if (!params.id_mmethod) return res.json(500, {error: "No meta method defined"});
if (!params.id_stu) return res.json(500, {error: "No student defined"});
if (!params.id_mmethod) return res.badRequest("No meta method defined");
if (!params.id_stu) return res.badRequest("No student defined");
// Find meta method
MetaMethod.findOne({id: params.id_mmethod}).exec(function(err, mmethod) {
if (err || !mmethod){
sails.log.debug("Finding meta method: " + err);
return;
}
sails.log.debug("Meta method found:" + mmethod);
MetaMethod.findOne({id: params.id_mmethod})
.then(mmethod => {
if (!mmethod)
throw new Error("Meta method not found");
// Create new method by meta method
Method.create({ name: mmethod.name, description: mmethod.description, student: params.id_stu}).exec(function (err, created) {
if (err) {
sails.log.debug("Creating new method: " + err);
return res.json(500, {error: 'Method not created'});
}
if (created) {
return Method.create(
{
name: mmethod.name,
description: mmethod.description,
student: params.id_stu
})
.then(created => created)
.fail(err => {throw err});
})
.then(created => {
// Find meta instructions associated to meta method
MetaInstruction.find({id_met: params.id_mmethod}).exec(function(err, minstructions) {
if (err || !minstructions || minstructions.length == 0){
sails.log.debug("Finding meta instructions of a meta method: " + err);
return;
}
sails.log.debug("Meta instructions found: " + JSON.stringify(minstructions));
MetaInstruction.find({id_met: params.id_mmethod})
.then(minstructions => {
if (!minstructions)
minstructions = [];
var l_ins = [];
// Every meta instruction is going to be created in 'Instruction'
// with .eachSeries the order of resulting array will be equal
// to the original array
async.eachSeries(minstructions, function(mins, callback) {
sails.log.debug("Loop adding meta instruction: " + mins.name + " to method " + created.id);
async.eachSeries(minstructions, function(mins, next) {
Instruction.create({
method: created.id,
name: mins.name,
objective: mins.objective
}).exec(function(err, added){
if(err) sails.log.debug("Instruction.create: " + err);
if(added){
})
.then(added => {
l_ins.push(added);
sails.log.debug("Instruction " + added.name + " added to method " + created.id);
}
callback();
});
// Finish function when each callback is done
// Optionaly it can be passed and err parameter
}, function(err){
if( err ) {
// One of the iterations produced an error.
// All processing will now stop.
} else {
return res.json({
})
.fail(err => {throw err})
.done(() => {next()});
},
function(err, results) {
if (err)
throw new Error("Error while looping through instructions");
return res.ok({
"name": created.name,
"description": created.description,
"id": created.id,
"student": created.id_stu,
"instructions": l_ins
});
}
});
});
}
});
})
.fail( err => {throw err});
})
.fail(err => {
return res.badRequest(err);
});
},
......
sails/src/api/controllers/StudentController.js
......@@ -608,6 +608,7 @@ module.exports = {
return res.json(l_met);
}
});
}
});
},
......@@ -1005,7 +1006,11 @@ module.exports = {
// Leave all rooms
for (var i = 0; i < rooms.length; i++) {
sails.sockets.leave(req.socket, rooms[i]);
//sails.sockets.leave(req.socket, rooms[i]); MODIFICADO POR FERNANDO. SI NO, NO SE ACTUALIZA UPDATE_PEERS
sails.hooks.rooms.unsubscribeFromRoom(
rooms[i],
req.socket
);
sails.log.debug("Unsusbscribe from room " + rooms[i]);
}
......
sails/src/api/controllers/WorkingSessionController.js
......@@ -55,7 +55,7 @@ module.exports = {
create: function(req, res) {
var params = req.allParams();
console.log(JSON.stringify(params));
sails.debug.log(JSON.stringify(params));
if (!params.id_sup) res.badRequest("No supervisor defined");
if (!params.id_ins) res.badRequest("No instruction defined");
......@@ -66,7 +66,7 @@ module.exports = {
data.supervisor = params.id_sup;
data.instruction = params.id_ins;
data.description = params.desc;
console.log("BEGIN " + params.begin);
sails.debug.log("BEGIN " + params.begin);
data.begin = params.begin; // data comes in ISO format
StuOpenTry.findOne({or: [ // pending open try?
......
sails/src/api/hooks/rooms.js
/**
* This hook is used for managing the rooms IDs.
* Every room created should call one of this functions in order
* to obtain an ID.
* @type {Object}
*/
var socketRooms={};
module.exports = function roomsHook (sails) {
return {
getRoom: function (socket) {
return socketRooms[sails.sockets.getId(socket)];
},
/**
* Special function that subscribes a socket to a given room.
* This creates the connection and logs to debug with this format:
......@@ -18,16 +25,20 @@ module.exports = function roomsHook (sails) {
* }
*
* @param {RoomID} room Room to subscribe
* @param {Socket} socket Socket added to the subscription
* @param {Socket} socket Socket added to the subscription<
*/
subscribeToRoom: function (room, socket) {
sails.log.debug('"websocketSubscribe":', JSON.stringify({
room: room,
socket: socket.id
}));
sails.sockets.join(socket, room, function () {
sails.io.sockets.in(room).clients(function(error, ids) {
if (!error) {
socketRooms[sails.sockets.getId(socket)] =
socketRooms[sails.sockets.getId(socket)] ? [socketRooms[sails.sockets.getId(socket)],room]
: [room];
sails.hooks.events.broadcastEvent(
room,
sails.hooks.events.roomSubscribersChange(ids.length)
......@@ -63,6 +74,12 @@ module.exports = function roomsHook (sails) {
room,
sails.hooks.events.roomSubscribersChange(ids.length)
);
if (socketRooms[sails.sockets.getId(socket)]) {
var index=socketRooms[sails.sockets.getId(socket)].indexOf(room);
if (index > -1) {
socketRooms[sails.sockets.getId(socket)].splice(index, 1);
}
}
}
});
});
......
sails/src/api/models/Instruction.js
......@@ -99,8 +99,10 @@ module.exports = {
},
// 3rd final function when everything is ready
function (err){
console.log("Final function recovering working sessions / tries / actions");
//console.log(JSON.stringify(l_ws));
if (err) {
console.log("Error recovering working sessions / tries / actions");
console.log("Error detail:"+JSON.stringify(err));
}
return callback(err, l_ws);
// If one iteration give an error it is sent to the controller
// with the list
......
sails/src/api/models/WorkingSession.js
......@@ -41,6 +41,7 @@ module.exports = {
},
current: {
type: "integer",
defaultsTo: 1
},
description: {
type: "string",
......@@ -55,7 +56,7 @@ module.exports = {
/**
* Checks a previous session is not opened for that supervisor. If so,
* session is closed (current is set to 0)
* session is closed (current is set NULL)
* @param {Object} attrs All session properties to be stored
* @param {Function} next Function to be executed when the check process
* has been completed (an error object will be passed
......@@ -66,9 +67,8 @@ module.exports = {
.then(function(wss) {
if (wss) {
async.each(wss, function(ws, cb) {
ws.current = 0;
WorkingSession.update(ws.id, ws, function(err, update) {
if (err) throw new Error("Error when udpating open sessions");
WorkingSession.update(ws.id, {current:null}, function(err, update) {
if (err) throw new Error("Error when udpating open sessions: "+JSON.stringify(err));
cb();
});
});
......
sails/src/assets/app/i18n/en-gb.json
......@@ -36,6 +36,7 @@
"birthdate": "Birthdate",
"cancel": "Cancel",
"cannot_delete_method": "Method could not be deleted, maybe due to existing recorded sessions.",
"cannot_delete_instruction": "Instruction could not be deleted, maybe due to existing recorded sessions.",
"categories": "Categories",
"category_pictograms": "Category's pictograms",
"change_password": "Change password",
......@@ -200,6 +201,7 @@
"register": "Sign in",
"remember": "Remember me",
"reports": "Reports",
"room_changed": "A partner is offline. Session paused.",
"save": "Save",
"save_as_template": "Save as template",
"search": "Search",
......@@ -216,6 +218,7 @@
"serial_list": "Free serial numbers",
"serial_not_created": "Serial number couldn't be created",
"session": "Session",
"sessions": "Sessions",
"session_mean_length": "Session mean length: {{hours}} hours",
"session_notes": "Session notes",
"sessions": "Sessions",
......@@ -258,6 +261,7 @@
"surname": "Surname",
"tag_deleted": "Tag deleted",
"tape_background": "Tape background",
"template_deleted": "Template deleted",
"time_instruction_method": "Time instructions of method",
"time_hours": "Time: {{hours}} hours",
"time_sessions_per_days": "Time of sessions per days in",
......@@ -298,7 +302,8 @@
"vibration": "Vibration",
"view": "View",
"voice": "Voice",
"warning_last_session_bad": "&nbsp;Last session was bad closed. <p/> &nbsp;Please, you must evaluate last tries before starting a new session",
"warning_last_session_bad": "&nbsp;Last session was bad closed. <p/> &nbsp;Please, you must evaluate last tries and press 'close seesion' button",
"warning_no_tablet_online":"No Pictogran Tablet online detected",
"woman": "Woman",
"year_totals": "Year totals",
"yes": "Yes",
......
sails/src/assets/app/i18n/es-es.json
......@@ -36,6 +36,7 @@
"birthdate": "Fecha de nacimiento",
"cancel": "Cancelar",
"cannot_delete_method": "No se pudo eliminar el método, tal vez porque existen sesiones asociadas.",
"cannot_delete_instruction": "No se pudo eliminar la instrucción, tal vez porque existen sesiones asociadas.",
"categories": "Categorías",
"category_pictograms": "Pictogramas de la categoría",
"change_password": "Cambiar contraseña",
......@@ -201,6 +202,7 @@
"register_button": "Registrar",
"remember": "No cerrar sesión",
"reports": "Informes",
"room_changed":"Un participante abandonó la sesión. Sesión en pausa.",
"save": "Guardar",
"save_as_template": "Guardar como plantilla",
"search": "Buscar",
......@@ -217,6 +219,7 @@
"serial_list": "Números de serie libres",
"serial_not_created": "No se ha podido crear el número de serie",
"session": "Sesión",
"sessions": "Sesiones",
"session_mean_length": "Duración media de sesión: {{hours}} horas",
"session_notes": "Notas de sesión",
"sessions": "Sesiones",
......@@ -259,6 +262,7 @@
"surname": "Apellidos",
"tag_deleted": "Etiqueta borrada",
"tape_background": "Fondo de la cinta",
"template_deleted": "Plantilla eliminada",
"time_hours": "Tiempo: {{hours}} horas",
"time_instruction_method": "Tiempo instrucciones del método",
"time_sessions_per_days": "Tiempo de sesiones por días en",
......@@ -299,7 +303,8 @@
"vibration": "Vibración",
"view": "Vista",
"voice": "Voz",
"warning_last_session_bad": "&nbsp;La última sesión no se cerró correctamente. <p/> &nbsp;Por favor, evalúe los ensayos correspondientes antes de iniciar una nueva sesión ",
"warning_last_session_bad": "&nbsp;La última sesión no se cerró correctamente. <p/> &nbsp;Por favor, evalúe los ensayos y pulse 'cerrar sesión' ",
"warning_no_tablet_online":"No se detectó ningún usuario de Pictogram Tablet online",
"woman": "Mujer",
"year_totals": "Totales año",
"yes": "Sí",
......
sails/src/assets/app/index.html
......@@ -5,6 +5,7 @@
<title>Pictogram Dashboard</title>
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<link rel="stylesheet" href="css/main.css">
<link rel="icon" href="img/logo_pictogram.png" type='image/png'>
<script src="js/libs.js"></script>
<script src="js/main.js"></script>
</head>
......
sails/src/assets/scripts/controllers/main.js
......@@ -12,6 +12,8 @@ String.prototype.hashCode = function() {
return hash;
};
io.sails.transports=['websocket'];
// Creamos el módulo dashboardControllers, de donde colgarán todos los controladores
var dashboardControllers = angular.module('dashboardControllers', ['dashboardConfig']);
......
sails/src/assets/scripts/modules/student/controllers/instructions.js
......@@ -89,7 +89,7 @@ dashboardControllers.controller('StudentInstructionsCtrl', function StudentInstr
console.log("Error from API: " + data.error);
});
}else{
} else {
// Add method from templates
$http
.post(config.backend+'/method', {
......@@ -113,18 +113,15 @@ dashboardControllers.controller('StudentInstructionsCtrl', function StudentInstr
// Delete template
$scope.delete_template = function(){
var deleteTemp = $window.confirm('Are you absolutely sure you want to delete?');
// If the method template is property of the supervisor
if(deleteTemp && $scope.method_selected.supervisor == $scope.user.id){
$translate('confirmation').then(function(translation) {
newconfirm(translation).then(function() {
if($scope.method_selected.supervisor == $scope.user.id){
$http
.delete(config.backend+'/method/template/' + $scope.method_selected.id)
.success(function(data, status, headers, config) {
console.log('Delete Method Template and its Instructions');
var myToastMsg = ngToast.success({
content: 'Eliminado método de plantillas',
timeout: 6000 // By default 4000
});
$translate('template_deleted').then(t => {ngToast.success({content: t})});
// Delete in select
for(var i=0; i<$scope.methods_available.length; i++) {
......@@ -139,6 +136,9 @@ dashboardControllers.controller('StudentInstructionsCtrl', function StudentInstr
console.log("Error from API: " + data.error);
});
}
});
});
};
// Update method
......@@ -291,6 +291,13 @@ dashboardControllers.controller('StudentInstructionsCtrl', function StudentInstr
})
.error(function(data, status, headers, config) {
console.log("Error from API: " + data.error);
var myToastMsg = $translate('cannot_delete_instruction').then(function (translation) {
// Show message
ngToast.warning({
content: translation,
timeout: 6000 // By default 4000
});
});
});
};
......
sails/src/assets/scripts/modules/student/controllers/session.js
......@@ -297,7 +297,8 @@ dashboardControllers.controller('StudentSessionCtrl', function StudentSessionCtr
.post(config.backend+'/action', {
"type": "pausesession",
"student": $scope.studentData.id,
"supervisor": $scope.user.id
"supervisor": $scope.user.id,
"timestamp": (new Date()).toISOString()
})
.success(function(data, status, headers, config) {
// Gettinf rid of last try and adding pause action to the list of actions
......@@ -318,7 +319,8 @@ dashboardControllers.controller('StudentSessionCtrl', function StudentSessionCtr
.post(config.backend+'/action', {
"type": "resumesession",
"student": $scope.studentData.id,
"supervisor": $scope.user.id
"supervisor": $scope.user.id,
"timestamp": (new Date()).toISOString()
})
.success(function(data, status, headers, config) {
// Adding pause action to the list of actions
......@@ -378,6 +380,22 @@ dashboardControllers.controller('StudentSessionCtrl', function StudentSessionCtr
//
io.socket.on('update_peers', function (data) {
if($scope.ws && $scope.actual_try.actions && $scope.paused == false && data.count<$scope.studentData.prev_num_peers) {
$scope.pause_ws();
$scope.pauseTimer();
$translate('room_changed').then(function (translation) {
ngToast.create({
className: 'warning',
content: translation,
dismissOnTimeout: false,
dismissButton: true
});
});
}
});
// Remove all listeners to this event
io.socket.off('action');
......@@ -388,7 +406,7 @@ dashboardControllers.controller('StudentSessionCtrl', function StudentSessionCtr
// doesn't know new data has come in. Inside the socket.io callback,
// as the last action, added $scope.apply() that lets angular know
// what data has updated, and refresh what needs to be refreshed.
//only events (i) from a student (and ii)when a try is opened are managed
if($scope.ws && $scope.actual_try.actions && !data.attributes.id_sup && $scope.paused == false){
switch(data.action){
......@@ -410,6 +428,7 @@ dashboardControllers.controller('StudentSessionCtrl', function StudentSessionCtr
}
}
$scope.$apply();
});
});
sails/src/assets/scripts/modules/student/controllers/student.js
......@@ -33,7 +33,8 @@ dashboardControllers.controller('StudentCtrl', function StudentCtrl(
name: ''
},
stuSup: [],
num_peers: 1
num_peers: 1,
prev_num_peers: 1
};
// For the user form data in setup section
......@@ -52,7 +53,10 @@ dashboardControllers.controller('StudentCtrl', function StudentCtrl(
// $translate('num_peers').then(function (translation) {
// ngToast.success(translation + ': ' + data.count);
//});
$scope.studentData.prev_num_peers = $scope.studentData.num_peers;
$scope.studentData.num_peers = data.count;
console.log('Usuarios conectados:'+$scope.studentData.num_peers+ " previamente:"+$scope.studentData.prev_num_peers);
$scope.$apply();
});
io.socket.on('reconnect', function () {
......
sails/src/assets/scripts/modules/student/views/header.html
......@@ -36,7 +36,7 @@
<a href="/app/#/student/{{studentData.id}}/instructions" ng-click="nav.tab = 'instructions'"><span class="glyphicon glyphicon-tasks" aria-hidden="true"></span> {{ 'instructions' | translate }}</a>
</li>
<li role="presentation" ng-class="{'active' : nav.tab == 'session'}" ng-if="studentData.supervision == 2">
<a href="/app/#/student/{{studentData.id}}/session" ng-click="nav.tab = 'session'"><span class="glyphicon glyphicon-transfer" aria-hidden="true"></span> {{ 'session' | translate }}</a>
<a href="/app/#/student/{{studentData.id}}/session" ng-click="nav.tab = 'session'"><span class="glyphicon glyphicon-transfer" aria-hidden="true"></span> {{ 'sessions' | translate }}</a>
</li>
<li role="presentation" ng-class="{'active' : nav.tab == 'reports'}" ng-if="studentData.supervision != 1">
<a href="/app/#/student/{{studentData.id}}/reports" ng-click="nav.tab = 'reports'"><span class="glyphicon glyphicon-file" aria-hidden="true"></span> {{ 'reports' | translate }}</a>
......
sails/src/assets/scripts/modules/student/views/session.html
<div class="panel panel-default student_tab_panel">
<div class="panel-body">
<div ng-show="studentData.num_peers<2" >
<table style="border: 1px solid #666666; padding:5px; background-color:#f5f5f5;" width="50%">
<tr>
<td><h4 translate>warning_no_tablet_online</h4></td>
</tr>
</table>
</div>
<div class="row">
<div class="col-md-6">
<form role="form" action="#">
<form role="form" action="#" ng-hide="ws_recover ">
<select class="form-control" name="met_select" id="met_select" ng-model="selectedMethod" ng-options="m.name for m in methods" ng-change="load_instructions(selectedMethod)">
<option value="" translate>select_a_method</option>
</select>
......@@ -15,7 +22,7 @@
<div class="row" ng-hide="!selectedIns">
<p class="session_controls">
<div class="col-md-4">
<a ng-click="startTimer(); new_ws()" ng-disabled="!selectedIns" ng-hide="sessionRunning" class="btn btn-success btn-sm" role="button" id="session_new" translate>new_session</a>
<a ng-click="startTimer(); new_ws()" ng-disabled="!selectedIns " ng-hide="sessionRunning || studentData.num_peers<2" class="btn btn-success btn-sm" role="button" id="session_new" translate>new_session</a>
<a class="text_large" ng-click="pause_ws(); pauseTimer();" ng-hide="!sessionRunning || paused" id="session_pause" popover="{{ 'pause_session' | translate}}" popover-trigger="mouseenter">
<span class="glyphicon glyphicon-pause" aria-hidden="true" title="{{ 'pause_session' | translate }}"></span>
</a>
......@@ -115,12 +122,9 @@
<span class="glyphicon glyphicon-chevron-up" aria-hidden="true" popover="{{ 'next_sessions' | translate}}" popover-trigger="mouseenter"></span>
</a>
</div>
<div class="list-group">
<div class="list-group-item" ng-repeat="s in wsessions | orderBy: '-begin' | limitTo: numPerPage:(currentPage-1)*numPerPage">
<div ng-show="showLastTry && wsessions.length > 0">
<h4><strong>{{ 'last_session' | translate}}</strong>: {{ studentData.current_method }}, {{ studentData.current_instruction }}</h4>
<div ng-show="ws_recover" >
<table style="border: 1px solid #666666; padding:5px; background-color:#f5f5f5;" width="100%">
<table style="border: 1px solid #666666; padding:5px; background-color:#f5f5f5;" width="50%">
<tr>
<td><h4 translate>warning_last_session_bad</h4></td>
<td>
......@@ -129,6 +133,10 @@
</tr>
</table>
</div>
<div class="list-group">
<div class="list-group-item" ng-repeat="s in wsessions | orderBy: '-begin' | limitTo: numPerPage:(currentPage-1)*numPerPage">
<div ng-show="showLastTry && wsessions.length > 0">
<h4><strong>{{ 'last_session' | translate}}</strong>: {{ studentData.current_method }}, {{ studentData.current_instruction }}</h4>
</div>
<button class="btn btn-primary pull-right" type="button" ng-click="showTries = !showTries">
{{ 'tries' | translate }}
......
sails/src/config/sockets.js
/**
* WebSocket Server Settings
* (sails.config.sockets)
......@@ -12,7 +13,7 @@
module.exports.sockets = {
pingTimeout: 300000, // set timeout to 5 minutes
pingTimeout: 20000, // set timeout to 20 secs
/***************************************************************************
* *
......@@ -23,8 +24,7 @@ module.exports.sockets = {
* automatically. *
* *
***************************************************************************/
/*onConnect: function(session, socket) {
/* onConnect: function(session, socket) {
},
*/
......@@ -34,11 +34,16 @@ module.exports.sockets = {
* disconnects *
* *
***************************************************************************/
/*onDisconnect: function(session, socket) {
// By default: do nothing.
afterDisconnect: function (session, socket, cb) {
var rooms=sails.hooks.rooms.getRoom(socket);
if (rooms)
for (var i = 0; i < rooms.length; i++) {
console.log("Unubscribed room in socket afterDisconnect: " + rooms[i]);
sails.hooks.rooms.unsubscribeFromRoom(rooms[i], socket);
}
},
*/
/***************************************************************************
* *
......@@ -49,12 +54,12 @@ module.exports.sockets = {
* flashsockets by adding 'flashsocket' to this list: *
* *
***************************************************************************/
transports: [
// transports: [
// 'websocket'
// 'htmlfile',
// 'xhr-polling'
'polling'
]
// 'polling'
// ]
/***************************************************************************
* *
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment