Create a gist now

Instantly share code, notes, and snippets.

What would you like to do?
This source code is for preprocessing our research data (personal user data behavior data)
### Author Information #####
### Coded by Rischan Mafrur ###
### 01/01/2015 ###
### For Thesis Purpose ###
### Language : R ###
### Dataset : Private Data ###
#Function for loading data
f_load_data <- function(path){
library(shiny)
library("RSQLite")
library("rjson")
library("ggplot2")
library("scales")
library("ggmap")
library("rmarkdown")
library("rmarkdown")
setwd(path)
driver <- dbDriver("SQLite")
file_list <- list.files()
for (file in file_list){
# if the merged dataset doesn't exist, create it
if (!exists("dataset")){
con <- dbConnect(driver,file)
dataset <- dbGetQuery(con,"Select * from data")
}
# if the merged dataset does exist, append to it
if (exists("dataset")){
con <- dbConnect(driver,file)
temp_dataset <-dbGetQuery(con,"Select * from data")
dataset<-rbind(dataset, temp_dataset)
rm(temp_dataset)
}
}
return (dataset)
}
#removing duplicate data
remove_duplicate <- function(data){
return (data[!duplicated(data),])
}
#function Activity data Processing
f_activity_data <- function(dataset){
dActivityProbe <- subset(dataset, dataset$name=="ActivityProbe")
#head(dActivityProbe)
myData <- lapply(dActivityProbe$value, fromJSON)
dActivityProbe$value <- as.character(do.call(rbind,lapply(myData, `[` ,'activityLevel')))
dActivityProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dActivityProbe$time <- as.character(as.POSIXlt(as.numeric(dActivityProbe$time), origin="1970-01-01", tz = "GMT"))
dA <- cbind(dActivityProbe$value,dActivityProbe$time)
dActivityProbe <- as.data.frame(dA)
names(dActivityProbe) <- c("Activity","Time")
return (dActivityProbe)
}
#dunction for load apps data
f_apps_data <- function(dataset){
dApplicationsProbe <- subset(dataset, dataset$name=="ApplicationsProbe")
#head(dApplicationsProbe)
myData <- lapply(dApplicationsProbe$value, fromJSON)
dApplicationsProbe$value <- as.character(do.call(rbind,lapply(myData, `[` ,'publicSourceDir')))
dApplicationsProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dApplicationsProbe$time <- as.character(as.POSIXlt(as.numeric(dApplicationsProbe$time), origin="1970-01-01", tz = "GMT"))
dA <- cbind(dApplicationsProbe$value,dApplicationsProbe$time)
dApplicationsProbe <- as.data.frame(dA)
names(dApplicationsProbe) <- c("Application","Time")
return (dApplicationsProbe)
}
#function for processing bluetooth data
f_bluetooth_data <- function(dataset){
dBluetoothProbe <- subset(dataset, dataset$name=="BluetoothProbe")
#head(dBluetoothProbe)
myData <- lapply(dBluetoothProbe$value, fromJSON)
dBluetoothProbe$device <- as.character(do.call(rbind,lapply(myData, `[` ,'android.bluetooth.device.extra.NAME')))
dBluetoothProbe$RSSI <- as.character(do.call(rbind,lapply(myData, `[` ,'android.bluetooth.device.extra.RSSI')))
dBluetoothProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dBluetoothProbe$time <- as.character(as.POSIXlt(as.numeric(dBluetoothProbe$time), origin="1970-01-01", tz = "GMT"))
dA <- cbind(dBluetoothProbe$device,dBluetoothProbe$RSSI, dBluetoothProbe$time)
dBluetoothProbe <- as.data.frame(dA)
names(dBluetoothProbe) <- c("BluetoothName","RSSI","Time")
#return (dBluetoothProbe)
return (dBluetoothProbe)
}
#function for processing battery data
f_battery_data <- function(dataset){
dBatteryProbe <- subset(dataset, dataset$name=="BatteryProbe")
#head(dBatteryProbe)
myData <- lapply(dBatteryProbe$value, fromJSON)
dBatteryProbe$charge_type <- as.character(do.call(rbind,lapply(myData, `[` ,'charge_type')))
dBatteryProbe$charge_type[dBatteryProbe$charge_type=="0"] <- "AC"
dBatteryProbe$charge_type[dBatteryProbe$charge_type=="1"] <- "USB"
dBatteryProbe$charge_type[dBatteryProbe$charge_type=="4"] <- "Wireless"
dBatteryProbe$health <- as.character(do.call(rbind,lapply(myData, `[` ,'health')))
dBatteryProbe$health[dBatteryProbe$health=="1"] <- "unknown"
dBatteryProbe$health[dBatteryProbe$health=="2"] <- "good"
dBatteryProbe$health[dBatteryProbe$health=="3"] <- "overheat"
dBatteryProbe$health[dBatteryProbe$health=="4"] <- "dead"
dBatteryProbe$health[dBatteryProbe$health=="5"] <- "over_voltage"
dBatteryProbe$health[dBatteryProbe$health=="6"] <- "unspecified_failure"
dBatteryProbe$health[dBatteryProbe$health=="7"] <- "cold"
dBatteryProbe$plugged <- as.character(do.call(rbind,lapply(myData, `[` ,'plugged')))
dBatteryProbe$plugged[dBatteryProbe$plugged=="0"] <- "on_battery"
dBatteryProbe$plugged[dBatteryProbe$plugged=="2"] <- "power_source"
dBatteryProbe$status <- as.character(do.call(rbind,lapply(myData, `[` ,'status')))
dBatteryProbe$status[dBatteryProbe$status=="1"] <- "unknown"
dBatteryProbe$status[dBatteryProbe$status=="2"] <- "charging"
dBatteryProbe$status[dBatteryProbe$status=="3"] <- "discharging"
dBatteryProbe$status[dBatteryProbe$status=="4"] <- "not_charging"
dBatteryProbe$status[dBatteryProbe$status=="5"] <- "full"
dBatteryProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dBatteryProbe$time <- as.character(as.POSIXlt(as.numeric(dBatteryProbe$time), origin="1970-01-01", tz = "GMT"))
dA <- cbind(dBatteryProbe$charge_type,dBatteryProbe$health,dBatteryProbe$plugged,dBatteryProbe$status,dBatteryProbe$time)
dBatteryProbe <- as.data.frame(dA)
names(dBatteryProbe) <- c("charge_type","health","plugged","status","time")
return (dBatteryProbe)
}
#function for processing call data
f_call_data <- function(dataset){
dCallLogProbe <- subset(dataset, dataset$name=="CallLogProbe")
#dCallLogProbe
#head(dCallLogProbe)
myData <- lapply(dCallLogProbe$value, fromJSON)
dCallLogProbe$date <- do.call(rbind,lapply(myData, `[` ,'date'))
dCallLogProbe$time_calling <- as.character(as.POSIXlt(as.numeric(substr(dCallLogProbe$date, 1, 10)), origin="1970-01-01", tz = "GMT"))
dCallLogProbe$duration <- as.character(do.call(rbind,lapply(myData, `[` ,'duration')))
dCallLogProbe$number <- substr(gsub("^.*:","",as.character(do.call(rbind,lapply(myData, `[` ,'number')))),2,41)
dCallLogProbe$type <- as.character(do.call(rbind,lapply(myData, `[` ,'type')))
dCallLogProbe$type[dCallLogProbe$type=="1"] <- "incoming"
dCallLogProbe$type[dCallLogProbe$type=="2"] <- "outgoing"
dCallLogProbe$type[dCallLogProbe$type=="3"] <- "missed"
dA <- cbind(dCallLogProbe$number, dCallLogProbe$type,dCallLogProbe$time_calling,dCallLogProbe$duration)
dCallLogProbe <- as.data.frame(dA)
names(dCallLogProbe) <- c("number","type","time","duration")
return (dCallLogProbe)
}
#function for processing sms data
f_sms_data <- function(dataset){
dSmsProbe <- subset(dataset, dataset$name=="SmsProbe")
#dSmsProbe
head(dSmsProbe)
myData <- lapply(dSmsProbe$value, fromJSON)
dSmsProbe$date <- do.call(rbind,lapply(myData, `[` ,'date'))
dSmsProbe$time <- as.character(as.POSIXlt(as.numeric(substr(dSmsProbe$date, 1, 10)), origin="1970-01-01", tz = "GMT"))
dSmsProbe$address <- as.character(do.call(rbind,lapply(myData, `[` ,'address')))
dSmsProbe$type <- as.character(do.call(rbind,lapply(myData, `[` ,'type')))
dSmsProbe$type[dSmsProbe$type=="0"] <- "all"
dSmsProbe$type[dSmsProbe$type=="1"] <- "inbox"
dSmsProbe$type[dSmsProbe$type=="2"] <- "sent"
dSmsProbe$type[dSmsProbe$type=="3"] <- "draft"
dSmsProbe$type[dSmsProbe$type=="4"] <- "outbox"
dSmsProbe$type[dSmsProbe$type=="5"] <- "failed"
dSmsProbe$type[dSmsProbe$type=="6"] <- "queued"
dSmsProbe$status <- as.character(do.call(rbind,lapply(myData, `[` ,'status')))
dSmsProbe$status[dSmsProbe$status=="-1"] <- "none"
dSmsProbe$status[dSmsProbe$status=="0"] <- "complete"
dSmsProbe$status[dSmsProbe$status=="32"] <- "pending"
dSmsProbe$status[dSmsProbe$status=="64"] <- "failed"
# dSmsProbe$body-byte-len <- as.character(do.call(rbind,lapply(myData, `[` ,'body-byte-len')))
# dSmsProbe$body-token-byte-len <- as.character(do.call(rbind,lapply(myData, `[` ,'body-token-byte-len')))
# dSmsProbe$body-token-count <- as.character(do.call(rbind,lapply(myData, `[` ,'body-token-count')))
dA <- cbind(dSmsProbe$time, dSmsProbe$type, dSmsProbe$address,dSmsProbe$status)
dSmsProbe <- as.data.frame(dA)
names(dSmsProbe) <- c("when", "type","address","status")
return (dSmsProbe)
}
#function for processing contact data
# f_contact_data <- function(dataset){
# dContactProbe <- subset(dataset, dataset$name=="ContactProbe")
# dContactProbe <- subset(dataset, dataset$name=="ContactProbe")
# myData <- lapply(dContactProbe$value, fromJSON)
# dContactProbe$date <- do.call(rbind,lapply(myData, `[` ,'date'))
# dContactProbe$time_calling <- as.character(as.POSIXlt(as.numeric(substr(dContactProbe$date, 1, 10)), origin="1970-01-01", tz = "GMT"))
# dContactProbe$duration <- as.character(do.call(rbind,lapply(myData, `[` ,'duration')))
# dContactProbe$number <- as.character(do.call(rbind,lapply(myData, `[` ,'number')))
# dContactProbe$type <- as.character(do.call(rbind,lapply(myData, `[` ,'type')))
# dContactProbe$type[dContactProbe$type=="1"] <- "incoming"
# dContactProbe$type[dContactProbe$type=="2"] <- "outgoing"
# dContactProbe$type[dContactProbe$type=="3"] <- "missed"
# dA <- cbind(dContactProbe$type, dContactProbe$number,dContactProbe$time_calling,dContactProbe$duration)
# dContactProbe <- as.data.frame(dA)
# names(dContactProbe) <- c("type","number","time","duration")
# summary(dContactProbe)
# return (dContactProbe)
#
# }
#function for processing hardware information data
f_hardware_data <- function(dataset){
dHardwareInfoProbe <- subset(dataset, dataset$name=="HardwareInfoProbe")
#head(dHardwareInfoProbe)
myData <- lapply(dHardwareInfoProbe$value, fromJSON)
dHardwareInfoProbe$brand <- as.character(do.call(rbind,lapply(myData, `[` ,'brand')))
dHardwareInfoProbe$model <- as.character(do.call(rbind,lapply(myData, `[` ,'model')))
dHardwareInfoProbe$bluetoothMac <- as.character(do.call(rbind,lapply(myData, `[` ,'bluetoothMac')))
dHardwareInfoProbe$wifiMac <- as.character(do.call(rbind,lapply(myData, `[` ,'wifiMac')))
dA <- cbind(dHardwareInfoProbe$brand,dHardwareInfoProbe$model,dHardwareInfoProbe$bluetoothMac,dHardwareInfoProbe$wifiMac)
dHardwareInfoProbe <- as.data.frame(dA)
names(dHardwareInfoProbe) <- c("brand","model","bluetoothMac", "wifiMac")
return (dHardwareInfoProbe)
}
#function for processing bookmark data
f_bookmark_data <- function(dataset){
dBrowserBookmarksProbe <- subset(dataset, dataset$name=="BrowserBookmarksProbe")
#head(dBrowserBookmarksProbe)
myData <- lapply(dBrowserBookmarksProbe$value, fromJSON)
dBrowserBookmarksProbe$time <- do.call(rbind,lapply(myData, `[` ,'created'))
dBrowserBookmarksProbe$when <- as.character(as.POSIXlt(as.numeric(dBrowserBookmarksProbe$time), origin="1970-01-01", tz = "GMT"))
dBrowserBookmarksProbe$title <- as.character(do.call(rbind,lapply(myData, `[` ,'title')))
dBrowserBookmarksProbe$url <- as.character(do.call(rbind,lapply(myData, `[` ,'url')))
dA <- cbind(dBrowserBookmarksProbe$when,dBrowserBookmarksProbe$title, dBrowserBookmarksProbe$url)
dBrowserBookmarksProbe <- as.data.frame(dA)
names(dBrowserBookmarksProbe) <- c("created","title","url")
return (dBrowserBookmarksProbe)
}
#function for processing searching log data
f_search_data <- function(dataset){
dBrowserSearchesProbe <- subset(dataset, dataset$name=="BrowserSearchesProbe")
#head(dBrowserSearchesProbe)
myData <- lapply(dBrowserSearchesProbe$value, fromJSON)
dBrowserSearchesProbe$time <- do.call(rbind,lapply(myData, `[` ,'date'))
dBrowserSearchesProbe$when <- as.character(as.POSIXlt(as.numeric(dBrowserSearchesProbe$time), origin="1970-01-01", tz = "GMT"))
dBrowserSearchesProbe$query <- as.character(do.call(rbind,lapply(myData, `[` ,'search')))
dA <- cbind(dBrowserSearchesProbe$when,dBrowserSearchesProbe$query)
dBrowserSearchesProbe <- as.data.frame(dA)
names(dBrowserSearchesProbe) <- c("when","query")
return (dBrowserSearchesProbe)
}
#function for processing light sensors data
f_light_data <- function(dataset){
dLightSensorProbe <- subset(dataset, dataset$name=="LightSensorProbe")
#head(dLightSensorProbe)
myData <- lapply(dLightSensorProbe$value, fromJSON)
dLightSensorProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dLightSensorProbe$timestamp <- as.character(as.POSIXlt(as.numeric(dLightSensorProbe$time), origin="1970-01-01", tz = "GMT"))
dLightSensorProbe$accuracy <- as.character(do.call(rbind,lapply(myData, `[` ,'accuracy')))
dLightSensorProbe$lux <- as.character(do.call(rbind,lapply(myData, `[` ,'lux')))
dA <- cbind(dLightSensorProbe$timestamp,dLightSensorProbe$accuracy, dLightSensorProbe$lux)
dLightSensorProbe <- as.data.frame(dA)
names(dLightSensorProbe) <- c("timestamp","accuracy","lux")
return (dLightSensorProbe)
}
#function for processing magnetic field sensor data
f_magno_data <- function(dataset){
dMagneticFieldSensorProbe <- subset(dataset, dataset$name=="MagneticFieldSensorProbe")
#head(dMagneticFieldSensorProbe)
myData <- lapply(dMagneticFieldSensorProbe$value, fromJSON)
dMagneticFieldSensorProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dMagneticFieldSensorProbe$timestamp <- as.character(as.POSIXlt(as.numeric(dMagneticFieldSensorProbe$time), origin="1970-01-01", tz = "GMT"))
dMagneticFieldSensorProbe$accuracy <- as.character(do.call(rbind,lapply(myData, `[` ,'accuracy')))
dMagneticFieldSensorProbe$accuracy[dMagneticFieldSensorProbe$accuracy=="1"] <- "low"
dMagneticFieldSensorProbe$accuracy[dMagneticFieldSensorProbe$accuracy=="2"] <- "medium"
dMagneticFieldSensorProbe$accuracy[dMagneticFieldSensorProbe$accuracy=="3"] <- "high"
dMagneticFieldSensorProbe$x <- as.character(do.call(rbind,lapply(myData, `[` ,'x')))
dMagneticFieldSensorProbe$y <- as.character(do.call(rbind,lapply(myData, `[` ,'y')))
dMagneticFieldSensorProbe$z <- as.character(do.call(rbind,lapply(myData, `[` ,'z')))
dA <- cbind(dMagneticFieldSensorProbe$timestamp,dMagneticFieldSensorProbe$accuracy, dMagneticFieldSensorProbe$x,dMagneticFieldSensorProbe$y, dMagneticFieldSensorProbe$z)
dMagneticFieldSensorProbe <- as.data.frame(dA)
names(dMagneticFieldSensorProbe) <- c("timestamp","accuracy","x","y","z")
return (dMagneticFieldSensorProbe)
}
#function for processing preassure data
f_pressure_data <- function(dataset){
dPressureSensorProbe <- subset(dataset, dataset$name=="PressureSensorProbe")
#head(dPressureSensorProbe)
myData <- lapply(dPressureSensorProbe$value, fromJSON)
dPressureSensorProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dPressureSensorProbe$timestamp <- as.character(as.POSIXlt(as.numeric(dPressureSensorProbe$time), origin="1970-01-01", tz = "GMT"))
dPressureSensorProbe$accuracy <- as.character(do.call(rbind,lapply(myData, `[` ,'accuracy')))
dPressureSensorProbe$pressure <- as.character(do.call(rbind,lapply(myData, `[` ,'pressure')))
dA <- cbind(dPressureSensorProbe$timestamp,dPressureSensorProbe$accuracy, dPressureSensorProbe$pressure)
dPressureSensorProbe <- as.data.frame(dA)
names(dPressureSensorProbe) <- c("timestamp","accuracy","pressure")
return (dPressureSensorProbe)
}
#function for processing proximity data
f_proximity_data <- function(dataset){
dProximitySensorProbe <- subset(dataset, dataset$name=="ProximitySensorProbe")
#head(dProximitySensorProbe)
myData <- lapply(dProximitySensorProbe$value, fromJSON)
dProximitySensorProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dProximitySensorProbe$timestamp <- as.character(as.POSIXlt(as.numeric(dProximitySensorProbe$time), origin="1970-01-01", tz = "GMT"))
dProximitySensorProbe$accuracy <- as.character(do.call(rbind,lapply(myData, `[` ,'accuracy')))
dProximitySensorProbe$distance <- as.character(do.call(rbind,lapply(myData, `[` ,'distance')))
dA <- cbind(dProximitySensorProbe$timestamp,dProximitySensorProbe$accuracy, dProximitySensorProbe$distance)
dProximitySensorProbe <- as.data.frame(dA)
names(dProximitySensorProbe) <- c("timestamp","accuracy","distance")
return (dProximitySensorProbe)
}
#function for processing running application data
f_runapps_data <- function(dataset){
dRunningApplicationsProbe <- subset(dataset, dataset$name=="RunningApplicationsProbe")
#head(dRunningApplicationsProbe)
myData <- lapply(dRunningApplicationsProbe$value, fromJSON)
dRunningApplicationsProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dRunningApplicationsProbe$timestamp <- as.character(as.POSIXlt(as.numeric(dRunningApplicationsProbe$time), origin="1970-01-01", tz = "GMT"))
dRunningApplicationsProbe$duration <- as.character(do.call(rbind,lapply(myData, function(x) x$duration)))
dRunningApplicationsProbe$package <- as.character(do.call(rbind,lapply(myData, function(x) x$taskInfo$baseIntent$mComponent$mPackage)))
dA <- cbind(dRunningApplicationsProbe$timestamp, dRunningApplicationsProbe$duration,dRunningApplicationsProbe$package)
dRunningApplicationsProbe <- as.data.frame(dA)
names(dRunningApplicationsProbe) <- c("timestamp","duration","package")
return (dRunningApplicationsProbe)
}
#function for processing screend data
f_screen_data <- function(dataset){
dScreenProbe <- subset(dataset, dataset$name=="ScreenProbe")
#head(dScreenProbe)
myData <- lapply(dScreenProbe$value, fromJSON)
dScreenProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dScreenProbe$timestamp <- as.character(as.POSIXlt(as.numeric(dScreenProbe$time), origin="1970-01-01", tz = "GMT"))
dScreenProbe$screenOn <- as.character(do.call(rbind,lapply(myData, `[` ,'screenOn')))
dA <- cbind(dScreenProbe$timestamp, dScreenProbe$screenOn)
dScreenProbe <- as.data.frame(dA)
names(dScreenProbe) <- c("timestamp","screenON")
return (dScreenProbe)
}
#function for processing location data
f_location_data <- function(dataset){
dSimpleLocationProbe <- subset(dataset, dataset$name=="SimpleLocationProbe")
#dSimpleLocationProbe
#head(dSimpleLocationProbe)
# location <-dSimpleLocationProbe
# location$latitude <- as.numeric(as.character(dSimpleLocationProbe$latitude))
# location$longitude <- as.numeric(as.character(dSimpleLocationProbe$longitude))
#
myData <- lapply(dSimpleLocationProbe$value, fromJSON)
dSimpleLocationProbe$Latitude <- as.character(do.call(rbind,lapply(myData, `[` ,'mLatitude')))
dSimpleLocationProbe$Longitude <- as.character(do.call(rbind,lapply(myData, `[` ,'mLongitude')))
dSimpleLocationProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dSimpleLocationProbe$when <- as.character(as.POSIXlt(as.numeric(dSimpleLocationProbe$time), origin="1970-01-01", tz = "GMT"))
dA <- cbind(dSimpleLocationProbe$when, dSimpleLocationProbe$Latitude , dSimpleLocationProbe$Longitude)
dSimpleLocationProbe <- as.data.frame(dA)
names(dSimpleLocationProbe) <- c("when","latitude","longitude")
return (dSimpleLocationProbe)
}
#function for processing wifi data
f_wifi_data <- function(dataset){
dWifiProbe <- subset(dataset, dataset$name=="WifiProbe")
#head(dWifiProbe)
myData <- lapply(dWifiProbe$value, fromJSON)
dWifiProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dWifiProbe$timestamp <- as.character(as.POSIXlt(as.numeric(dWifiProbe$time), origin="1970-01-01", tz = "GMT"))
dWifiProbe$BSSID <- as.character(do.call(rbind,lapply(myData, `[` ,'BSSID')))
dWifiProbe$SSID <- as.character(do.call(rbind,lapply(myData, `[` ,'SSID')))
dWifiProbe$capabilities <- as.character(do.call(rbind,lapply(myData, `[` ,'capabilities')))
dWifiProbe$frequency <- as.character(do.call(rbind,lapply(myData, `[` ,'frequency')))
dWifiProbe$level <- as.character(do.call(rbind,lapply(myData, `[` ,'level')))
dA <- cbind(dWifiProbe$timestamp, dWifiProbe$BSSID,dWifiProbe$SSID,dWifiProbe$capabilities,dWifiProbe$frequency,dWifiProbe$level)
dWifiProbe <- as.data.frame(dA)
names(dWifiProbe) <- c("timestamp","BSSID","SSID","capabilities","frequency","level")
return (dWifiProbe)
}
#
#
# raw_data <- f_load_data(print(eval(sprintf("D:/DATA/raw/ENTJ_6454/edu.mit.media.funf.wifiscanner/default/archive",file))))
# #removing duplicate data
# dataset <- remove_duplicate(raw_data)
#
#
# dWifiProbe <- subset(dataset, dataset$name=="WifiProbe")
# head(dWifiProbe)
# myData <- lapply(dWifiProbe$value, fromJSON)
# dWifiProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
# dWifiProbe$timestamp <- as.character(dWifiProbe$time)
# dWifiProbe$BSSID <- as.character(do.call(rbind,lapply(myData, `[` ,'BSSID')))
# dWifiProbe$SSID <- as.character(do.call(rbind,lapply(myData, `[` ,'SSID')))
# dWifiProbe$capabilities <- as.character(do.call(rbind,lapply(myData, `[` ,'capabilities')))
# dWifiProbe$frequency <- as.character(do.call(rbind,lapply(myData, `[` ,'frequency')))
# dWifiProbe$level <- as.character(do.call(rbind,lapply(myData, `[` ,'level')))
# dA <- cbind(dWifiProbe$timestamp, dWifiProbe$BSSID,dWifiProbe$SSID,dWifiProbe$capabilities,dWifiProbe$frequency,dWifiProbe$level)
# dWifiProbe <- as.data.frame(dA)
# names(dWifiProbe) <- c("timestamp","BSSID","SSID","capabilities","frequency","level")
#
# #function for processing call data
#
# dCallLogProbe <- subset(dataset, dataset$name=="CallLogProbe")
# #dCallLogProbe
# head(dCallLogProbe)
# tail(dCallLogProbe)
#
# myData <- lapply(dCallLogProbe$value, fromJSON)
# dCallLogProbe$date <- do.call(rbind,lapply(myData, `[` ,'date'))
# dCallLogProbe$time_calling <- as.character(as.POSIXct(as.numeric(substr(dCallLogProbe$date,1,10)), origin="1970-01-01", tz = "GMT"))
# dCallLogProbe$duration <- as.character(do.call(rbind,lapply(myData, `[` ,'duration')))
# dCallLogProbe$number <- substr(gsub("^.*:","",as.character(do.call(rbind,lapply(myData, `[` ,'number')))),2,41)
# dCallLogProbe$type <- as.character(do.call(rbind,lapply(myData, `[` ,'type')))
# dCallLogProbe$type[dCallLogProbe$type=="1"] <- "incoming"
# dCallLogProbe$type[dCallLogProbe$type=="2"] <- "outgoing"
# dCallLogProbe$type[dCallLogProbe$type=="3"] <- "missed"
# dA <- cbind(dCallLogProbe$number, dCallLogProbe$type,dCallLogProbe$time_calling,dCallLogProbe$duration)
# dCallLogProbe <- as.data.frame(dA)
# names(dCallLogProbe) <- c("number","type","time","duration")
#
#
#
# #function for processing sms data
#
# dSmsProbe <- subset(dataset, dataset$name=="SmsProbe")
# #dSmsProbe
# head(dSmsProbe)
# tail(dSmsProbe)
# myData <- lapply(dSmsProbe$value, fromJSON)
# dSmsProbe$date <- do.call(rbind,lapply(myData, `[` ,'date'))
# dSmsProbe$time <- as.character(as.POSIXct(as.numeric(substr(dSmsProbe$date, 1, 10)), origin="1970-01-01", tz = "GMT"))
# dSmsProbe$address <- as.character(do.call(rbind,lapply(myData, `[` ,'address')))
# dSmsProbe$type <- as.character(do.call(rbind,lapply(myData, `[` ,'type')))
# dSmsProbe$type[dSmsProbe$type=="0"] <- "all"
# dSmsProbe$type[dSmsProbe$type=="1"] <- "inbox"
# dSmsProbe$type[dSmsProbe$type=="2"] <- "sent"
# dSmsProbe$type[dSmsProbe$type=="3"] <- "draft"
# dSmsProbe$type[dSmsProbe$type=="4"] <- "outbox"
# dSmsProbe$type[dSmsProbe$type=="5"] <- "failed"
# dSmsProbe$type[dSmsProbe$type=="6"] <- "queued"
# dSmsProbe$status <- as.character(do.call(rbind,lapply(myData, `[` ,'status')))
# dSmsProbe$status[dSmsProbe$status=="-1"] <- "none"
# dSmsProbe$status[dSmsProbe$status=="0"] <- "complete"
# dSmsProbe$status[dSmsProbe$status=="32"] <- "pending"
# dSmsProbe$status[dSmsProbe$status=="64"] <- "failed"
# # dSmsProbe$body-byte-len <- as.character(do.call(rbind,lapply(myData, `[` ,'body-byte-len')))
# # dSmsProbe$body-token-byte-len <- as.character(do.call(rbind,lapply(myData, `[` ,'body-token-byte-len')))
# # dSmsProbe$body-token-count <- as.character(do.call(rbind,lapply(myData, `[` ,'body-token-count')))
# dA <- cbind(dSmsProbe$time, dSmsProbe$type, dSmsProbe$address,dSmsProbe$status)
# dSmsProbe <- as.data.frame(dA)
# names(dSmsProbe) <- c("when", "type","address","status")
#
#
#
#
#
# #
# #running application
# # #
# raw_data <- f_load_data("D:/DATA/raw/ENFP_0719/edu.mit.media.funf.wifiscanner/default/archive")
# #removing duplicate data
# dataset <- remove_duplicate(raw_data)
# #subsetting
# d_activity <- f_activity_data(dataset)
# d_bluetooth <- f_bluetooth_data(dataset)
# d_battery <- f_battery_data(dataset)
# d_call <- f_call_data(dataset)
# d_sms <- f_sms_data(dataset)
# d_search <- f_search_data(dataset)
# d_runapps <- f_runapps_data(dataset)
# d_screen <- f_screen_data(dataset)
# d_location <- f_location_data(dataset)
# d_wifi <- f_wifi_data(dataset)
#
# write.csv(d_activity, print(eval(sprintf("D:/DATA/output/%s/d_activity.csv",file))))
# write.csv(d_bluetooth, print(eval(sprintf("D:/DATA/output/%s/d_bluetooth.csv",file))))
# write.csv(d_battery, print(eval(sprintf("D:/DATA/output/%s/d_battery.csv",file))))
# write.csv(d_call, print(eval(sprintf("D:/DATA/output/%s/d_call.csv",file))))
# write.csv(d_sms, print(eval(sprintf("D:/DATA/output/%s/d_sms.csv",file))))
# write.csv(d_search, print(eval(sprintf("D:/DATA/output/%s/d_search.csv",file))))
# write.csv(d_runapps, print(eval(sprintf("D:/DATA/output/%s/d_runapps.csv",file))))
# write.csv(d_screen, print(eval(sprintf("D:/DATA/output/%s/d_screen.csv",file))))
# write.csv(d_location, print(eval(sprintf("D:/DATA/output/%s/d_location.csv",file))))
# write.csv(d_wifi, print(eval(sprintf("D:/DATA/output/%s/d_wifi.csv",file))))
#
# d_sms <- d_sms[order(d_sms$when),]
#
# # #
# # # #problem ENFP_0773
#
#
setwd("D:/DATA/kampret")
file_list <- list.files()
for (file in file_list){
#print(eval(sprintf("D:/DATA/output/%s/d_location.csv",file)))
dir.create(print(eval(sprintf("D:/DATA/output/%s",file))))
}
for (file in file_list){
dataset <- NULL
d_activity <- NULL
d_bluetooth <- NULL
d_battery <- NULL
d_call <- NULL
d_sms <- NULL
d_search <- NULL
d_runapps <- NULL
d_screen <- NULL
d_location <- NULL
d_wifi <- NULL
raw_data <- f_load_data(print(eval(sprintf("D:/DATA/kampret/%s/edu.mit.media.funf.wifiscanner/default/archive",file))))
#removing duplicate data
dataset <- remove_duplicate(raw_data)
#subsetting
d_activity <- f_activity_data(dataset)
d_bluetooth <- f_bluetooth_data(dataset)
d_battery <- f_battery_data(dataset)
d_call <- f_call_data(dataset)
d_sms <- f_sms_data(dataset)
d_search <- f_search_data(dataset)
d_runapps <- f_runapps_data(dataset)
d_screen <- f_screen_data(dataset)
d_location <- f_location_data(dataset)
d_wifi <- f_wifi_data(dataset)
write.csv(d_activity, print(eval(sprintf("D:/DATA/output/%s/d_activity.csv",file))))
write.csv(d_bluetooth, print(eval(sprintf("D:/DATA/output/%s/d_bluetooth.csv",file))))
write.csv(d_battery, print(eval(sprintf("D:/DATA/output/%s/d_battery.csv",file))))
write.csv(d_call, print(eval(sprintf("D:/DATA/output/%s/d_call.csv",file))))
write.csv(d_sms, print(eval(sprintf("D:/DATA/output/%s/d_sms.csv",file))))
write.csv(d_search, print(eval(sprintf("D:/DATA/output/%s/d_search.csv",file))))
write.csv(d_runapps, print(eval(sprintf("D:/DATA/output/%s/d_runapps.csv",file))))
write.csv(d_screen, print(eval(sprintf("D:/DATA/output/%s/d_screen.csv",file))))
write.csv(d_location, print(eval(sprintf("D:/DATA/output/%s/d_location.csv",file))))
write.csv(d_wifi, print(eval(sprintf("D:/DATA/output/%s/d_wifi.csv",file))))
}
# for (file in file_list){
# #print(paste(file))
# #print(eval(sprintf("D:/DATA/example/%s/edu.mit.media.funf.wifiscanner/default/archive",file)))
# "D:/DATA/output/"paste(file, collapse = "")),showWarnings = TRUE)
# print(eval(sprintf("D:/DATA/output/%s",file)))
# }
#
# ?eval
#
# paste("Today is", date(),"dads")
# paste(1:12)
#?system.time
#run all function and show time execution for each function
#
# system.time(dataset <- f_load_data("D:/DATA/example"))
# system.time(d_activity <- f_activity_data(dataset))
# system.time(d_apps <- f_apps_data(dataset))
# system.time(d_bluetooth <- f_bluetooth_data(dataset))
# system.time(d_battery <- f_battery_data(dataset))
# system.time(d_call <- f_call_data(dataset))
# # system.time(d_contact <- f_contact_data(dataset))
# system.time(d_sms <- f_sms_data(dataset))
# system.time(d_hardware <- f_hardware_data(dataset))
# system.time(d_bookmark <- f_bookmark_data(dataset))
# system.time(d_search <- f_search_data(dataset))
# system.time(d_light <- f_light_data(dataset))
# system.time(d_magno <- f_magno_data(dataset))
# system.time(d_pressure <- f_pressure_data(dataset))
# system.time(d_proximity <- f_proximity_data(dataset))
# system.time(d_runapps <- f_runapps_data(dataset))
# system.time(d_screen <- f_screen_data(dataset))
# system.time(d_location <- f_location_data(dataset))
# system.time(d_wifi <- f_wifi_data(dataset))
#
#loading data
#raw_data <- f_load_data("D:/DATA/raw/ENFP_0719/edu.mit.media.funf.wifiscanner/default/archive")
#removing duplicate data
#dataset <- remove_duplicate(raw_data)
# d_activity <- f_activity_data(dataset)
# d_apps <- f_apps_data(dataset)
# d_bluetooth <- f_bluetooth_data(dataset)
# d_battery <- f_battery_data(dataset)
# d_call <- f_call_data(dataset)
# #d_contact <- f_contact_data(dataset)
# d_sms <- f_sms_data(dataset)
# d_hardware <- f_hardware_data(dataset)
# d_bookmark <- f_bookmark_data(dataset)
# d_search <- f_search_data(dataset)
# d_light <- f_light_data(dataset)
# d_magno <- f_magno_data(dataset)
# d_pressure <- f_pressure_data(dataset)
# d_proximity <- f_proximity_data(dataset)
# d_runapps <- f_runapps_data(dataset)
# head(d_runapps)
# d_screen <- f_screen_data(dataset)
# d_location <- f_location_data(dataset)
# d_wifi <- f_wifi_data(dataset)
# url <- c("facebook.com","twitter.com","facebook.com","facebook.com","twitter.com","facebook.com","chonnam.com")
#
# seque <- seq(1,7)
#
# df <- cbind(seque,url)
#
# df <- as.data.frame(df)
#
# df$label <- NULL
# df$label[df$url=="facebook.com"] <- "sosmed"
# df$label[df$url=="twitter.com"] <- "sosmed"
# df$label[df$url=="chonnam.com"] <- "kampus"
as.POSIXct(d_activity$time, format="%Y-%m-%d %H:%M:%S")
dataset <- f_load_data(print(eval(sprintf("D:/DATA/raw/ENTJ_6454/edu.mit.media.funf.wifiscanner/default/archive",file))))
dActivityProbe <- subset(dataset, dataset$name=="ActivityProbe")
head(dActivityProbe)
myData <- lapply(dActivityProbe$value, fromJSON)
dActivityProbe$value <- as.character(do.call(rbind,lapply(myData, `[` ,'activityLevel')))
dActivityProbe$time <- do.call(rbind,lapply(myData, `[` ,'timestamp'))
dActivityProbe$time <- as.character(as.POSIXct(as.numeric(dActivityProbe$time), origin="1970-01-01", tz = "GMT"))
dA <- cbind(dActivityProbe$value,dActivityProbe$time)
dActivityProbe <- as.data.frame(dA)
names(dActivityProbe) <- c("Activity","Time")
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment