--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <Types.h>
+#include <ContextManager.h>
+#include <Json.h>
+#include "AppInactiveDetector.h"
+#include "AppInactiveDetectorTypes.h"
+#include "InactiveDetector.h"
+
+
+ctx::app_inactive_detector_provider *ctx::app_inactive_detector_provider::__instance = NULL;
+
+ctx::app_inactive_detector_provider::app_inactive_detector_provider()
+{
+}
+
+ctx::app_inactive_detector_provider::~app_inactive_detector_provider()
+{
+}
+
+ctx::ContextProviderBase *ctx::app_inactive_detector_provider::create(void *data)
+{
+ IF_FAIL_RETURN(!__instance, __instance);
+ __instance = new(std::nothrow) app_inactive_detector_provider();
+ IF_FAIL_RETURN_TAG(__instance, NULL, _E, "Memory allocation failed");
+ _I(BLUE("Created"));
+ return __instance;
+}
+
+void ctx::app_inactive_detector_provider::destroy(void *data)
+{
+ IF_FAIL_VOID(__instance);
+ delete __instance;
+ __instance = NULL;
+ _I(BLUE("Destroyed"));
+}
+
+int ctx::app_inactive_detector_provider::subscribe(const char *subject, ctx::Json option, ctx::Json* request_result)
+{
+ return ERR_NOT_SUPPORTED;
+}
+
+int ctx::app_inactive_detector_provider::unsubscribe(const char *subject, ctx::Json option)
+{
+ return ERR_NOT_SUPPORTED;
+}
+
+int ctx::app_inactive_detector_provider::read(const char *subject, ctx::Json option, ctx::Json* request_result)
+{
+ _I(BLUE("Read"));
+ _J("Option", option);
+
+ int error = engine->read(subject, option);
+ return error == ERR_NONE ? ERR_NONE : error;
+}
+
+int ctx::app_inactive_detector_provider::write(const char *subject, ctx::Json data, ctx::Json* request_result)
+{
+ return ERR_NOT_SUPPORTED;
+}
+
+bool ctx::app_inactive_detector_provider::is_supported()
+{
+ return true;
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_APP_INACTIVE_DETECTOR_H__
+#define __CONTEXT_APP_INACTIVE_DETECTOR_H__
+
+#include <ContextProviderBase.h>
+#include "AppInactiveDetectorTypes.h"
+#include "InactiveDetector.h"
+
+namespace ctx {
+
+ class app_inactive_detector_provider : public ContextProviderBase {
+
+ public:
+ static ContextProviderBase *create(void *data);
+ static void destroy(void *data);
+ static bool is_supported();
+
+ int subscribe(const char *subject, ctx::Json option, ctx::Json *request_result);
+ int unsubscribe(const char *subject, ctx::Json option);
+ int read(const char *subject, ctx::Json option, ctx::Json *request_result);
+ int write(const char *subject, ctx::Json data, ctx::Json *request_result);
+
+ private:
+ static app_inactive_detector_provider *__instance;
+ inactive_detector *engine;
+
+ app_inactive_detector_provider();
+ ~app_inactive_detector_provider();
+
+ }; /* class app_inactive_detector_provider */
+
+} /* namespace ctx */
+
+#endif /* __CONTEXT_APP_INACTIVE_DETECTOR_H__ */
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_APP_INACTIVE_DETECTOR_TYPES__
+#define __CONTEXT_APP_INACTIVE_DETECTOR_TYPES__
+
+#include <string>
+
+// Context Items
+//#define APP_INACTIVE_SUBJ_RECALCULATE "app/recalculate"
+#define APP_INACTIVE_SUBJ_GET_APPS_INACTIVE "app/inactive"
+#define APP_INACTIVE_SUBJ_GET_APPS_ACTIVE "app/active"
+#define APP_INACTIVE_SUBJ_GET_APPS_WEIGHT "app/weight"
+#define APP_INACTIVE_SUBJ_UPDATE_CLUSTERS "app/update"
+
+enum {
+ APP_INACTIVE_QUERY_ID_GET_APPS_WEIGHT = 1,
+ APP_INACTIVE_QUERY_ID_GET_APPS_INACTIVE = 2,
+ APP_INACTIVE_QUERY_ID_GET_APPS_ACTIVE = 3,
+ APP_INACTIVE_QUERY_ID_UPDATE_CLUSTERS = 4
+};
+
+// Database
+#define APP_INACTIVE_DETECTOR_APPINFO_TABLE "context_app_info"
+#define APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "app_info"
+#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID "_id"
+#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME "package_name"
+#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_TYPE "package_type"
+#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY "is_nodisplay"
+#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED "is_enabled"
+#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT "is_atboot"
+#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED "is_preloaded"
+#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_TIMESTAMP "timestamp"
+
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE "context_app_launch_log"
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE_ALIAS "app_launch_log"
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_ID "_id"
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_CONTEXT_APP_INFO_ID "context_app_info_id"
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_DURATION "duration"
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_SYSTEM_VOLUME "system_volume"
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_BSSID "bssid"
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_TIMESTAMP "timestamp"
+#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_TIMESTAMP_UTC "timestamp_utc"
+
+#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE "context_app_activity_classified"
+#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "app_activity_classified"
+#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_ID "_id"
+#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID "context_app_info_id"
+#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_ACTIVITY_RATE "activity_rate"
+#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME "timeframe"
+#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE "is_active"
+
+
+#define APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS "virtual_app_history"
+#define APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT "weight"
+
+// Output Data Key
+#define APP_INACTIVE_DETECTOR_DATA_READ "AppsList"
+#define APP_INACTIVE_DETECTOR_DATA_TIMESTAMP_FROM "timestamp_from"
+#define APP_INACTIVE_DETECTOR_ACTIVITY_RATE "activity_rate"
+#define APP_INACTIVE_DETECTOR_DATA_TIMEFRAME "timeframe"
+#define APP_INACTIVE_DETECTOR_DATA_ISACTIVE "is_active"
+
+//Other
+#define APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMESTAMP "$timestamp"
+#define APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_CLUSTER "$cluster"
+#define APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME "$timeframe"
+#define APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_VALUES "$values"
+
+// Objects
+struct app_t {
+ int id;
+ std::string package_name;
+ int is_nodisplay;
+ int is_enabled;
+ int is_atboot;
+ int is_preloaded;
+ double timestamp;
+ int weight;
+ int is_active;
+ int timeframe;
+};
+
+
+#define APP_TYPE_INACTIVE_INACTIVE 1
+#define APP_TYPE_INACTIVE_ACTIVE 2
+
+
+#define APP_INACTIVE_TASK_START_HOUR 3
+#define APP_INACTIVE_TASK_START_MINUTE 0
+
+
+#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEDAY 60*60*24
+#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_THREEDAYS 60*60*24*3
+#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEWEEK 60*60*24*7
+#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_TWOWEEKS 60*60*24*14
+#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEMONTH 60*60*24*31
+
+
+
+#endif /* __CONTEXT_APP_INACTIVE_DETECTOR_TYPES__ */
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ctime>
+#include <Types.h>
+#include "InactiveDetector.h"
+#include "InactiveDetectorWeight.h"
+#include "InactiveDetectorStorage.h"
+#include "InactiveDetectorClassificator.h"
+#include "TimerManager.h"
+
+ctx::inactive_detector::inactive_detector()
+{
+ timer_id = timer_mgr.setAt( // execute once every night
+ APP_INACTIVE_TASK_START_HOUR,
+ APP_INACTIVE_TASK_START_MINUTE,
+ DayOfWeek::EVERYDAY,
+ this);
+ if (timer_id < 0) {
+ _E("inactive_detector timer set FAIL");
+ return;
+ } else {
+ update_clusters();
+ _D("inactive_detector timer set SUCCESS");
+ }
+
+}
+
+ctx::inactive_detector::~inactive_detector()
+{
+ if (timer_id >= 0) {
+ timer_mgr.remove(timer_id);
+ _D("inactive_detejctor timer removed");
+ }
+
+}
+
+bool ctx::inactive_detector::onTimerExpired(int timerId)
+{
+ update_clusters();
+ return true;
+}
+
+int ctx::inactive_detector::update_clusters()
+{
+ // define timeframes stack
+ std::vector<int> timeframes;
+ timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEDAY);
+ timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_THREEDAYS);
+ timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEWEEK);
+ timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_TWOWEEKS);
+ timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEMONTH);
+
+ // recalculate weights
+ // foreach timeframe
+ for(std::vector<int>::iterator timeframe = timeframes.begin();
+ timeframe != timeframes.end(); timeframe++)
+ {
+ inactive_detector_weight i_detector_weight;
+ int error = i_detector_weight.request_weights(*timeframe);
+ _E("update_clusters request_weights:%d, error:%d", *timeframe, error);
+ }
+
+ return ERR_NONE;
+}
+
+void ctx::inactive_detector::on_cluster_update_finished(std::vector<app_t> *apps_with_weight, int error)
+{
+ if (error == ERR_NONE) {
+ _I("on_cluster_update_finished success");
+ }
+ // clean memory
+ delete apps_with_weight;
+}
+
+int ctx::inactive_detector::read(
+ const char *subject,
+ ctx::Json option)
+{
+ ctx::inactive_detector_storage *handle = new(std::nothrow) ctx::inactive_detector_storage();
+ IF_FAIL_RETURN_TAG(handle, ERR_OPERATION_FAILED, _E, "Memory allocation failed");
+
+ int err = handle->read(subject, option);
+ if (err != ERR_NONE) {
+ delete handle;
+ return err;
+ }
+
+ return ERR_NONE;
+}
+
+ctx::Json ctx::inactive_detector::to_json(std::vector<app_t> *app_infos)
+{
+ ctx::Json data;
+
+ for(std::vector<app_t>::iterator app_info = app_infos->begin();
+ app_info != app_infos->end(); app_info++)
+ {
+ ctx::Json app_j;
+ app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME, app_info->package_name);
+ app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY, app_info->is_nodisplay);
+ app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED, app_info->is_enabled);
+ app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT, app_info->is_atboot);
+ app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED, app_info->is_preloaded);
+ app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_TIMESTAMP, app_info->timestamp);
+ }
+ return data;
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_INACTIVE_DETECTOR_H__
+#define __CONTEXT_INACTIVE_DETECTOR_H__
+
+#include <string>
+#include <Json.h>
+#include <vector>
+#include "AppInactiveDetectorTypes.h"
+#include <TimerManager.h>
+
+namespace ctx {
+
+ class inactive_detector : public ITimerListener {
+ private:
+ int timer_id;
+ TimerManager timer_mgr;
+ public:
+ inactive_detector();
+ ~inactive_detector();
+
+ int read(const char *subject,
+ ctx::Json option);
+
+ int update_clusters();
+ void on_cluster_update_finished(
+ std::vector<app_t> *apps_classified,
+ int error);
+ ctx::Json to_json(std::vector<app_t> *apps);
+
+ bool onTimerExpired(int timerId);
+ }; /* class inactive_detector */
+
+} /* namespace ctx */
+
+
+#endif /* __CONTEXT_INACTIVE_DETECTOR_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <Types.h>
+#include "InactiveDetector.h"
+#include "AppInactiveDetectorTypes.h"
+#include "InactiveDetectorClassificator.h"
+#include "InactiveDetectorClassificatorKmeans.h"
+
+int ctx::inactive_detector_classificator::classify(std::vector<app_t> *apps_with_weights)
+{
+ inactive_detector_classificator_kmeans kmeans;
+ int error = kmeans.classify(apps_with_weights);
+
+ return error;
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_H__
+#define __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_H__
+
+#include <vector>
+#include "AppInactiveDetectorTypes.h"
+#include <Json.h>
+
+namespace ctx {
+
+ class inactive_detector_classificator
+ {
+ public:
+ inactive_detector_classificator();
+ ~inactive_detector_classificator();
+
+ int classify(std::vector<app_t> *apps_with_weights);
+ }; /* class inactive_detector_classificator */
+
+} /* namespace ctx */
+
+#endif /* __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <Types.h>
+#include "AppInactiveDetectorTypes.h"
+#include "InactiveDetectorClassificatorKmeans.h"
+#include "InactiveDetectorClassificatorKmeansTypes.h"
+#include <math.h>
+#include <stdlib.h>
+
+double ctx::inactive_detector_classificator_kmeans::randomf(double x)
+{
+ return x * rand() / (RAND_MAX - 1.);
+}
+
+double ctx::inactive_detector_classificator_kmeans::glide_function(double x)
+{
+ double value = sqrt(log(x) + 1);
+ return (value > 0 ? value : 0);
+}
+
+point_s *ctx::inactive_detector_classificator_kmeans::reproject_to_2d(std::vector<app_t> *apps_with_weights)
+{
+ int distr_size = apps_with_weights->size();
+ point_s *p = new point_s[distr_size];
+
+ int i=0;
+ for(std::vector<app_t>::iterator apps_with_weight = apps_with_weights->begin();
+ apps_with_weight != apps_with_weights->end(); apps_with_weight++)
+ {
+ point_s the_point;
+
+ the_point.x = glide_function(apps_with_weight->weight); // normalize weight values
+ the_point.y = 0; //remove 3rd dimension of the data
+ the_point.origin_id = apps_with_weight->package_name;
+
+ p[i] = the_point;
+ i++;
+ }
+
+ return p;
+}
+
+bool ctx::inactive_detector_classificator_kmeans::annotate_data(std::vector<app_t> *apps_with_weights, point_s *c)
+{
+ int i=0, max_group=-1;
+
+ for(std::vector<app_t>::iterator apps_with_weight = apps_with_weights->begin();
+ apps_with_weight != apps_with_weights->end(); apps_with_weight++)
+ {
+ apps_with_weight->is_active = c[i].group;
+ i++;
+ max_group = c[i].group > max_group ? c[i].group : max_group;
+ }
+
+ return max_group == APP_INACTIVE_DETECTOR_KMEANS_CLUSTER_COUNT;
+}
+
+double ctx::inactive_detector_classificator_kmeans::distance_to(point_s *p_from,
+ point_s *p_to)
+{
+ double x = p_from->x - p_to->x, y = p_from->y - p_to->y;
+ return x*x + y*y;
+}
+
+int ctx::inactive_detector_classificator_kmeans::nearest(point_s *pt,
+ point_s *centers,
+ int cluster_number,
+ double *distance)
+{
+ int i;
+ int min_i = pt->group;
+ point_s *c;
+
+ double d;
+ double min_d = HUGE_VAL;
+
+ for_n {
+ if (min_d >(d = distance_to(c, pt))) {
+ min_d = d; min_i = i;
+ }
+ }
+
+ if (distance) *distance = min_d;
+ return min_i;
+}
+
+void ctx::inactive_detector_classificator_kmeans::kpp(point_s *points, int length, point_s *centers, int cluster_number)
+{
+ int j;
+ int n_cluster;
+ double sum;
+ double *d = new double[length];
+
+ point_s *p;
+ centers[0] = points[rand() % length];
+ for (n_cluster = 1; n_cluster < cluster_number; n_cluster++) {
+ sum = 0;
+ for_len{
+ nearest(p, centers, n_cluster, d + j);
+ sum += d[j];
+ }
+ sum = randomf(sum);
+ for_len{
+ if ((sum -= d[j]) > 0) continue;
+ centers[n_cluster] = points[j];
+ break;
+ }
+ }
+ for_len p->group = nearest(p, centers, n_cluster, 0);
+
+ delete d;
+}
+
+point_s *ctx::inactive_detector_classificator_kmeans::lloyd(point_s *points, int length, int cluster_number)
+{
+ int i, j, min_i;
+ int changed;
+
+ point_s *centers = new point_s;
+ point_s *p, *c;
+
+ /* k++ init */
+ kpp(points, length, centers, cluster_number);
+
+ do {
+ /* group element for centroids are used as counters */
+ for_n{ c->group = 0; c->x = c->y = 0; }
+ for_len{
+ c = centers + p->group;
+ c->group++;
+ c->x += p->x; c->y += p->y;
+ }
+ for_n{ c->x /= c->group; c->y /= c->group; }
+
+ changed = 0;
+ /* find closest centroid of each point */
+ for_len{
+ min_i = nearest(p, centers, cluster_number, 0);
+ if (min_i != p->group) {
+ changed++;
+ p->group = min_i;
+ }
+ }
+ } while (changed > (length >> 10)); /* stop when 99.9% of points are good */
+
+ for_n{ c->group = i; }
+
+ return centers;
+}
+
+int ctx::inactive_detector_classificator_kmeans::classify(std::vector<app_t> *apps_with_weights)
+{
+ //array of generated points
+ point_s *v = reproject_to_2d(apps_with_weights);
+ //mark cluster for each point, output centers
+ point_s *c = lloyd(v, apps_with_weights->size(), APP_INACTIVE_DETECTOR_KMEANS_CLUSTER_COUNT);
+ //append the result to input data
+ bool classification_is_success = annotate_data(apps_with_weights, c);
+
+ return classification_is_success ? ERR_NONE : ERR_OPERATION_FAILED;
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_H__
+#define __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_H__
+
+#include <vector>
+#include "InactiveDetectorClassificatorKmeansTypes.h"
+#include <Json.h>
+
+namespace ctx {
+
+ #define for_n for (c = centers, i = 0; i < cluster_number; i++, c++)
+ #define for_len for (j = 0, p = points; j < length; j++, p++)
+
+ class inactive_detector_classificator_kmeans
+ {
+ private:
+ double randomf(double x);
+ double glide_function(double x);
+ point_s *reproject_to_2d(std::vector<app_t> *apps_with_weights);
+ bool annotate_data(std::vector<app_t> *apps_with_weights, point_s *c);
+
+ double distance_to(point_s *p_from, point_s *p_to);
+ int nearest(point_s *pt, point_s *centers, int cluster_number, double *distance);
+ void kpp(point_s *points, int length, point_s *centers, int centers_count);
+ point_s *lloyd(point_s *points, int length, int cluster_number);
+ public:
+ inactive_detector_classificator_kmeans();
+ ~inactive_detector_classificator_kmeans();
+
+ int classify(std::vector<app_t> *apps_with_weights);
+ }; /* class inactive_detector_classificator_kmeans */
+} /* namespace ctx */
+
+#endif /* __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_APP_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_TYPES__
+#define __CONTEXT_APP_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_TYPES__
+
+#define APP_INACTIVE_DETECTOR_KMEANS_CLUSTER_COUNT 2
+
+typedef struct {
+ std::string origin_id;
+ double x;
+ double y;
+ int group;
+} point_s;
+
+#endif
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sstream>
+#include <ctime>
+#include <string>
+#include <memory>
+#include <Types.h>
+#include "InactiveDetector.h"
+#include "InactiveDetectorStorage.h"
+#include "InactiveDetectorStorageQueries.h"
+#include "InactiveDetectorClassificator.h"
+#include "AppInactiveDetectorTypes.h"
+
+/*int ctx::inactive_detector_storage::create_table()
+{
+ bool ret = __dbManager.createTable(0, WIFI_TABLE_NAME, WIFI_CREATE_TABLE_COLUMNS, NULL, NULL);
+ _D("Table Creation Request: %s", ret ? "SUCCESS" : "FAIL");
+ return ret;
+}*/
+
+
+
+// expected Json format example: {timeframe: 1; is_active: 0}
+int ctx::inactive_detector_storage::read(
+ const char *subject,
+ ctx::Json filter)
+{
+ std::string query;
+ query = query_get_apps(subject, filter);
+
+ IF_FAIL_RETURN(!query.empty(), ERR_OPERATION_FAILED);
+
+ bool ret = __dbManager.execute(
+ STR_EQ(subject, APP_INACTIVE_SUBJ_GET_APPS_INACTIVE) ?
+ APP_INACTIVE_QUERY_ID_GET_APPS_INACTIVE :
+ APP_INACTIVE_QUERY_ID_GET_APPS_ACTIVE,
+ query.c_str(),
+ this);
+
+ IF_FAIL_RETURN(ret, ERR_OPERATION_FAILED);
+
+ return ERR_NONE;
+}
+
+std::string ctx::inactive_detector_storage::query_get_apps(const char *subject, ctx::Json filter)
+{
+ double timeframe;
+ int is_active;
+
+ std::string query(GET_APP_INFO_INACTIVE_QUERY);
+ std::string placeholder_timeframe(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME);
+ std::string placeholder_is_active(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_CLUSTER);
+
+ filter.get(NULL, APP_INACTIVE_DETECTOR_DATA_TIMEFRAME, &timeframe);
+ filter.get(NULL, APP_INACTIVE_DETECTOR_DATA_ISACTIVE, &is_active);
+
+ std::stringstream timeframe_stream;
+ timeframe_stream << timeframe;
+
+ std::stringstream is_active_stream;
+ is_active_stream << is_active;
+
+ inject_params(query, placeholder_timeframe, timeframe_stream.str());
+ inject_params(query, placeholder_is_active, is_active_stream.str());
+
+ return query;
+}
+
+std::string ctx::inactive_detector_storage::query_update_apps(std::vector<app_t> *apps_with_weights)
+{
+ std::string delete_query(DELETE_APP_ACTIVITY_CLASSIFIED_BY_TIMEFRAME);
+ std::string insert_query(INSERT_APP_ACTIVITY_CLASSIFIED);
+ std::string placeholder_timeframe(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME);
+ std::string placeholder_values(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_VALUES);
+ std::string placeholder_is_active(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_CLUSTER);
+
+ std::stringstream timeframe_stream;
+ timeframe_stream << apps_with_weights->front().timeframe;
+
+ inject_params(delete_query, placeholder_timeframe, timeframe_stream.str());
+ inject_params(insert_query, placeholder_values, subquery_form_values(apps_with_weights));
+
+ std::stringstream result;
+ result << delete_query << insert_query;
+ return result.str();
+}
+
+// foreach app_info id+cluster -> select for insert
+std::string ctx::inactive_detector_storage::subquery_form_values(std::vector<app_t> *apps_with_weights)
+{
+ std::stringstream select_elements;
+
+ for(std::vector<app_t>::iterator row = apps_with_weights->begin();
+ row != apps_with_weights->end(); row++)
+ {
+ //SELECT 1 as is_active, 1 as timeframe, 3964 as context_app_info_id
+ std::stringstream select_element;
+ select_element << " SELECT " << row->is_active << " as ";
+ select_element << APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE;
+ select_element << ", " << row->timeframe << " as ";
+ select_element << APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME;
+ select_element << ", " << row->id << " as ";
+ select_element << APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID;
+
+ if ((row != apps_with_weights->end()) && (row == --apps_with_weights->end()))
+ select_element << " UNION ";
+
+ select_elements << select_element;
+ }
+
+ return select_elements.str();
+}
+
+void ctx::inactive_detector_storage::json_to_object(std::vector<Json>& records,
+ std::vector<app_t> *apps_with_weights, bool result_mode)
+{
+ for(std::vector<Json>::iterator row = records.begin();
+ row != records.end(); row++)
+ {
+ app_t app_with_weight;
+ if (result_mode)
+ {
+ row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME,
+ &app_with_weight.package_name);
+ row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY,
+ &app_with_weight.is_nodisplay);
+ row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED,
+ &app_with_weight.is_enabled);
+ row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT,
+ &app_with_weight.is_atboot);
+ row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED,
+ &app_with_weight.is_preloaded);
+ row->get(NULL, APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT,
+ &app_with_weight.weight);
+ }
+ else
+ {
+ row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID,
+ &app_with_weight.id);
+ row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_TIMESTAMP,
+ &app_with_weight.timestamp);
+ row->get(NULL, APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT,
+ &app_with_weight.weight);
+ row->get(NULL, APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE,
+ &app_with_weight.is_active);
+ }
+
+ apps_with_weights->push_back(app_with_weight);
+ }
+}
+
+void ctx::inactive_detector_storage::onExecuted(unsigned int query_id,
+ int error,
+ std::vector<Json>& records)
+{
+ if (error != ERR_NONE) {
+ _E("query_id:%d, error:%d", query_id, error);
+ return;
+ }
+
+ std::vector<app_t> *apps_with_weights = NULL;
+ if (query_id == APP_INACTIVE_QUERY_ID_GET_APPS_INACTIVE ||
+ query_id == APP_INACTIVE_QUERY_ID_GET_APPS_ACTIVE)
+ {
+ json_to_object(records, apps_with_weights, TRUE);
+ }
+ else if (query_id == APP_INACTIVE_QUERY_ID_GET_APPS_WEIGHT) {
+
+ json_to_object(records, apps_with_weights, FALSE);
+
+ if (apps_with_weights->size() > 0) {
+ inactive_detector_classificator i_detector_classificator;
+ int _error = i_detector_classificator.classify(apps_with_weights);
+
+ if(_error == ERR_NONE)
+ {
+ std::string query;
+ query = query_update_apps(apps_with_weights);
+ bool ret = __dbManager.execute(APP_INACTIVE_QUERY_ID_UPDATE_CLUSTERS,
+ query.c_str(),
+ this);
+ _D("load visits execute query result: %s", ret ? "SUCCESS" : "FAIL");
+ }
+ else
+ {
+ _E("classification query_id:%d, error:%d",
+ query_id, _error);
+ }
+ }
+ }
+ else if (query_id == APP_INACTIVE_QUERY_ID_UPDATE_CLUSTERS) {
+ _D("UPDATE_CLUSTERS execute query id: %d", query_id);
+ }
+ else {
+ _E("unknown query_id:%d", query_id);
+ }
+}
+
+void ctx::inactive_detector_storage::inject_params(std::string& str, const std::string& from, const std::string& to)
+{
+ if(from.empty())
+ return;
+ size_t start_pos = 0;
+ while((start_pos = str.find(from, start_pos)) != std::string::npos) {
+ str.replace(start_pos, from.length(), to);
+ start_pos += to.length();
+ }
+}
+
+// normalzie weights
+int ctx::inactive_detector_storage::update_ranks()
+{
+ return ERR_NONE;
+}
+
+int ctx::inactive_detector_storage::get_apps_info_w_weights(
+ double timestamp_from)
+{
+ std::stringstream timestamp_stream;
+ timestamp_stream << timestamp_from;
+ std::string timestamp_str = timestamp_stream.str();
+
+ std::string query(GET_APP_INFO_W_WEIGHT_QUERY);
+ std::string placeholder(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMESTAMP);
+
+ inject_params(query, placeholder, timestamp_str);
+
+ bool ret = __dbManager.execute(APP_INACTIVE_QUERY_ID_GET_APPS_WEIGHT,
+ query.c_str(),
+ this);
+ _D("load visits execute query result: %s", ret ? "SUCCESS" : "FAIL");
+
+ return ERR_NONE ;
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_INACTIVE_DETECTOR_STORAGE_H__
+#define __CONTEXT_INACTIVE_DETECTOR_STORAGE_H__
+
+#include <vector>
+#include "AppInactiveDetectorTypes.h"
+#include <Json.h>
+#include <DatabaseManager.h>
+
+namespace ctx {
+
+ class inactive_detector_storage : public IDatabaseListener
+ {
+ private:
+ //int type; //TODO: enum
+ void inject_params(std::string& str,
+ const std::string& from,
+ const std::string& to);
+
+ void json_to_object(std::vector<Json>& records,
+ std::vector<app_t> *apps_with_weights, bool result_mode);
+
+ std::string query_get_apps(const char *subject,
+ ctx::Json filter);
+
+ std::string query_update_apps(std::vector<app_t> *apps_with_weights);
+
+ std::string subquery_form_values(std::vector<app_t> *apps_with_weights);
+
+ void onTableCreated(unsigned int query_id, int error) {}
+ void onInserted(unsigned int query_id, int error, int64_t row_id) {}
+ void onExecuted(unsigned int query_id, int error, std::vector<Json>& records);
+
+ DatabaseManager __dbManager;
+
+ public:
+ inactive_detector_storage();
+ ~inactive_detector_storage();
+
+ int read(const char *subject,
+ ctx::Json filter);
+
+ int update_ranks();
+ int get_apps_info_w_weights(double timestamp_from);
+ }; /* class inactive_detector_storage */
+
+} /* namespace ctx */
+
+#endif /* __CONTEXT_INACTIVE_DETECTOR_STORAGE_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_INACTIVE_DETECTOR_STORAGE_QUERIES_H__
+#define __CONTEXT_INACTIVE_DETECTOR_STORAGE_QUERIES_H__
+
+#include <vector>
+#include "AppInactiveDetectorTypes.h"
+
+/*
+
+--1 calculate weights
+SELECT
+ app_info._id,
+ app_info.package_name,
+ app_info.is_nodisplay,
+ app_info.is_enabled,
+ app_info.is_atboot,
+ app_info.is_preloaded,
+ app_info.timestamp,
+
+ app_hist_g.weight as weight
+FROM
+ context_app_info app_info
+
+INNER JOIN
+
+ (SELECT
+ distinct package_name ,
+ IFNULL((select count(package_name) from context_app_launch_log
+ where package_name == app_hist.package_name AND timestamp> 8640412900), 0 )
+ *
+ IFNULL((select sum(duration) from context_app_launch_log
+ where package_name == app_hist.package_name AND timestamp> 8640412900) , 0)
+ as weight
+
+ FROM context_app_launch_log app_hist
+)app_hist_g
+
+ON app_hist_g.package_name
+=
+app_info.package_name
+
+ORDER BY app_hist_g.weight
+
+*/
+
+#define GET_APP_INFO_W_WEIGHT_QUERY "SELECT "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_TYPE ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_TIMESTAMP ", "\
+ ""\
+ " " APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT \
+ ""\
+ " FROM " APP_INACTIVE_DETECTOR_APPINFO_TABLE " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS \
+ ""\
+ " INNER JOIN " \
+ " (SELECT "\
+ " DISTINCT " APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME "," \
+ " IFNULL((SELECT COUNT(" APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME ")" \
+ " FROM " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE \
+ " WHERE " APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME "==" APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME \
+ " AND " \
+ " " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_TIMESTAMP " >= " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMESTAMP \
+ "), 0) " \
+ " * " \
+ " IFNULL((SELECT SUM(" APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_DURATION ")" \
+ " FROM " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE \
+ " WHERE " APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME "==" APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME \
+ " AND " \
+ " " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_TIMESTAMP " >= " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMESTAMP \
+ ""\
+ "), 0) " \
+ " as " APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT \
+ " FROM " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE " " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE_ALIAS \
+ ") " APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS \
+ " ON " APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME \
+ " = " \
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME \
+ " ORDER BY " APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT
+
+/*
+--2 select inner join context_app_info
+SELECT
+ app_info.package_name,
+ app_info.is_nodisplay,
+ app_info.is_enabled,
+ app_info.is_atboot,
+ app_info.is_preloaded,
+
+ activity_classified.activity_rate
+
+FROM
+ context_activity_classified activity_classified
+INNER JOIN
+ context_app_info app_info
+ON activity_classified.context_app_info_id = app_info._id
+
+WHERE
+ activity_classified.is_active = 1
+ AND
+ activity_classified.timeframe = 1
+*/
+
+#define GET_APP_INFO_INACTIVE_QUERY "SELECT "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT ", "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED ", "\
+ " "\
+ " " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_ACTIVITY_RATE " "\
+ " FROM "\
+ " " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE " " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS " "\
+ " INNER JOIN "\
+ " " APP_INACTIVE_DETECTOR_APPINFO_TABLE " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS " "\
+ " ON " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID ""\
+ " = " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID " "\
+ " WHERE "\
+ APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE ""\
+ " = " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_CLUSTER ""\
+ " AND "\
+ " " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME ""\
+ " = " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME ""
+
+/*
+--3 update ranks and clusters for each timeframe: delete all for each time frame, add new calculations for apps
+DELETE FROM
+ context_activity_classified
+WHERE
+ timeframe = 1
+*/
+
+#define DELETE_APP_ACTIVITY_CLASSIFIED_BY_TIMEFRAME "DELETE FROM "\
+ APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE \
+ " WHERE "\
+ " timeframe = " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME
+
+
+/*INSERT INTO
+ context_activity_classified
+ (is_active,
+ timeframe,
+ context_app_info_id)
+SELECT
+ is_active,
+ timeframe,
+ context_app_info_id
+FROM --make loop
+ (
+ SELECT 1 as is_active, 1 as timeframe, 3964 as context_app_info_id
+ UNION
+ SELECT 0 as is_active, 1 as timeframe, 3964 as context_app_info_id
+ ) q
+*/
+
+#define INSERT_APP_ACTIVITY_CLASSIFIED " INSERT INTO "\
+ APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE \
+ "( " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE ", "\
+ APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME ", "\
+ APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID ")" \
+"SELECT " \
+ APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE "," \
+ APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME ", "\
+ APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID \
+"FROM"\
+ "(" \
+ APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_VALUES \
+ ") q"
+
+
+
+#endif /* __CONTEXT_INACTIVE_DETECTOR_STORAGE_QUERIES_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <Types.h>
+#include "InactiveDetectorWeight.h"
+#include "InactiveDetectorStorage.h"
+
+int ctx::inactive_detector_weight::request_weights(
+ double timestamp_from)
+{
+ inactive_detector_storage ids;
+ // query the database for the result
+ int error = ids.get_apps_info_w_weights(timestamp_from);
+
+ return error;
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CONTEXT_INACTIVE_DETECTOR_WEIGHT_H__
+#define __CONTEXT_INACTIVE_DETECTOR_WEIGHT_H__
+
+// #include <string>
+// #include <sstream>
+
+namespace ctx {
+
+ class inactive_detector_weight {
+ public:
+ inactive_detector_weight() {};
+ ~inactive_detector_weight() {};
+ int request_weights(double timestamp_from);// {};
+ }; /* class inactive_detector_weight */
+
+} /* namespace ctx */
+
+#endif /* __CONTEXT_INACTIVE_DETECTOR_WEIGHT_H__ */
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <Types.h>
-#include <ContextManager.h>
-#include <Json.h>
-#include "app_inactive_detector.h"
-#include "app_inactive_detector_types.h"
-#include "inactive_detector.h"
-
-
-ctx::app_inactive_detector_provider *ctx::app_inactive_detector_provider::__instance = NULL;
-
-ctx::app_inactive_detector_provider::app_inactive_detector_provider()
-{
-}
-
-ctx::app_inactive_detector_provider::~app_inactive_detector_provider()
-{
-}
-
-ctx::ContextProviderBase *ctx::app_inactive_detector_provider::create(void *data)
-{
- IF_FAIL_RETURN(!__instance, __instance);
- __instance = new(std::nothrow) app_inactive_detector_provider();
- IF_FAIL_RETURN_TAG(__instance, NULL, _E, "Memory allocation failed");
- _I(BLUE("Created"));
- return __instance;
-}
-
-void ctx::app_inactive_detector_provider::destroy(void *data)
-{
- IF_FAIL_VOID(__instance);
- delete __instance;
- __instance = NULL;
- _I(BLUE("Destroyed"));
-}
-
-int ctx::app_inactive_detector_provider::subscribe(const char *subject, ctx::Json option, ctx::Json* request_result)
-{
- return ERR_NOT_SUPPORTED;
-}
-
-int ctx::app_inactive_detector_provider::unsubscribe(const char *subject, ctx::Json option)
-{
- return ERR_NOT_SUPPORTED;
-}
-
-int ctx::app_inactive_detector_provider::read(const char *subject, ctx::Json option, ctx::Json* request_result)
-{
- _I(BLUE("Read"));
- _J("Option", option);
-
- int error = engine->read(subject, option);
- return error == ERR_NONE ? ERR_NONE : error;
-}
-
-int ctx::app_inactive_detector_provider::write(const char *subject, ctx::Json data, ctx::Json* request_result)
-{
- return ERR_NOT_SUPPORTED;
-}
-
-bool ctx::app_inactive_detector_provider::is_supported()
-{
- return true;
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_APP_INACTIVE_DETECTOR_H__
-#define __CONTEXT_APP_INACTIVE_DETECTOR_H__
-
-#include <ContextProviderBase.h>
-#include "app_inactive_detector_types.h"
-#include "inactive_detector.h"
-
-namespace ctx {
-
- class app_inactive_detector_provider : public ContextProviderBase {
-
- public:
- static ContextProviderBase *create(void *data);
- static void destroy(void *data);
- static bool is_supported();
-
- int subscribe(const char *subject, ctx::Json option, ctx::Json *request_result);
- int unsubscribe(const char *subject, ctx::Json option);
- int read(const char *subject, ctx::Json option, ctx::Json *request_result);
- int write(const char *subject, ctx::Json data, ctx::Json *request_result);
-
- private:
- static app_inactive_detector_provider *__instance;
- inactive_detector *engine;
-
- app_inactive_detector_provider();
- ~app_inactive_detector_provider();
-
- }; /* class app_inactive_detector_provider */
-
-} /* namespace ctx */
-
-#endif /* __CONTEXT_APP_INACTIVE_DETECTOR_H__ */
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_APP_INACTIVE_DETECTOR_TYPES__
-#define __CONTEXT_APP_INACTIVE_DETECTOR_TYPES__
-
-#include <string>
-
-// Context Items
-//#define APP_INACTIVE_SUBJ_RECALCULATE "app/recalculate"
-#define APP_INACTIVE_SUBJ_GET_APPS_INACTIVE "app/inactive"
-#define APP_INACTIVE_SUBJ_GET_APPS_ACTIVE "app/active"
-#define APP_INACTIVE_SUBJ_GET_APPS_WEIGHT "app/weight"
-#define APP_INACTIVE_SUBJ_UPDATE_CLUSTERS "app/update"
-
-enum {
- APP_INACTIVE_QUERY_ID_GET_APPS_WEIGHT = 1,
- APP_INACTIVE_QUERY_ID_GET_APPS_INACTIVE = 2,
- APP_INACTIVE_QUERY_ID_GET_APPS_ACTIVE = 3,
- APP_INACTIVE_QUERY_ID_UPDATE_CLUSTERS = 4
-};
-
-// Database
-#define APP_INACTIVE_DETECTOR_APPINFO_TABLE "context_app_info"
-#define APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "app_info"
-#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID "_id"
-#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME "package_name"
-#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_TYPE "package_type"
-#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY "is_nodisplay"
-#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED "is_enabled"
-#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT "is_atboot"
-#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED "is_preloaded"
-#define APP_INACTIVE_DETECTOR_APPINFO_COLUMN_TIMESTAMP "timestamp"
-
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE "context_app_launch_log"
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE_ALIAS "app_launch_log"
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_ID "_id"
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_CONTEXT_APP_INFO_ID "context_app_info_id"
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_DURATION "duration"
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_SYSTEM_VOLUME "system_volume"
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_BSSID "bssid"
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_TIMESTAMP "timestamp"
-#define APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_TIMESTAMP_UTC "timestamp_utc"
-
-#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE "context_app_activity_classified"
-#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "app_activity_classified"
-#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_ID "_id"
-#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID "context_app_info_id"
-#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_ACTIVITY_RATE "activity_rate"
-#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME "timeframe"
-#define APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE "is_active"
-
-
-#define APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS "virtual_app_history"
-#define APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT "weight"
-
-// Output Data Key
-#define APP_INACTIVE_DETECTOR_DATA_READ "AppsList"
-#define APP_INACTIVE_DETECTOR_DATA_TIMESTAMP_FROM "timestamp_from"
-#define APP_INACTIVE_DETECTOR_ACTIVITY_RATE "activity_rate"
-#define APP_INACTIVE_DETECTOR_DATA_TIMEFRAME "timeframe"
-#define APP_INACTIVE_DETECTOR_DATA_ISACTIVE "is_active"
-
-//Other
-#define APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMESTAMP "$timestamp"
-#define APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_CLUSTER "$cluster"
-#define APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME "$timeframe"
-#define APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_VALUES "$values"
-
-// Objects
-struct app_t {
- int id;
- std::string package_name;
- int is_nodisplay;
- int is_enabled;
- int is_atboot;
- int is_preloaded;
- double timestamp;
- int weight;
- int is_active;
- int timeframe;
-};
-
-
-#define APP_TYPE_INACTIVE_INACTIVE 1
-#define APP_TYPE_INACTIVE_ACTIVE 2
-
-
-#define APP_INACTIVE_TASK_START_HOUR 3
-#define APP_INACTIVE_TASK_START_MINUTE 0
-
-
-#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEDAY 60*60*24
-#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_THREEDAYS 60*60*24*3
-#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEWEEK 60*60*24*7
-#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_TWOWEEKS 60*60*24*14
-#define CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEMONTH 60*60*24*31
-
-
-
-#endif /* __CONTEXT_APP_INACTIVE_DETECTOR_TYPES__ */
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <ctime>
-#include <Types.h>
-#include "inactive_detector.h"
-#include "inactive_detector_weight.h"
-#include "inactive_detector_storage.h"
-#include "inactive_detector_classificator.h"
-#include "TimerManager.h"
-
-ctx::inactive_detector::inactive_detector()
-{
- timer_id = timer_mgr.setAt( // execute once every night
- APP_INACTIVE_TASK_START_HOUR,
- APP_INACTIVE_TASK_START_MINUTE,
- DayOfWeek::EVERYDAY,
- this);
- if (timer_id < 0) {
- _E("inactive_detector timer set FAIL");
- return;
- } else {
- update_clusters();
- _D("inactive_detector timer set SUCCESS");
- }
-
-}
-
-ctx::inactive_detector::~inactive_detector()
-{
- if (timer_id >= 0) {
- timer_mgr.remove(timer_id);
- _D("inactive_detejctor timer removed");
- }
-
-}
-
-bool ctx::inactive_detector::onTimerExpired(int timerId)
-{
- update_clusters();
- return true;
-}
-
-int ctx::inactive_detector::update_clusters()
-{
- // define timeframes stack
- std::vector<int> timeframes;
- timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEDAY);
- timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_THREEDAYS);
- timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEWEEK);
- timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_TWOWEEKS);
- timeframes.push_back(CONTEXT_HISTORY_FILTER_TIME_INTERVAL_ONEMONTH);
-
- // recalculate weights
- // foreach timeframe
- for(std::vector<int>::iterator timeframe = timeframes.begin();
- timeframe != timeframes.end(); timeframe++)
- {
- inactive_detector_weight i_detector_weight;
- int error = i_detector_weight.request_weights(*timeframe);
- _E("update_clusters request_weights:%d, error:%d", *timeframe, error);
- }
-
- return ERR_NONE;
-}
-
-void ctx::inactive_detector::on_cluster_update_finished(std::vector<app_t> *apps_with_weight, int error)
-{
- if (error == ERR_NONE) {
- _I("on_cluster_update_finished success");
- }
- // clean memory
- delete apps_with_weight;
-}
-
-int ctx::inactive_detector::read(
- const char *subject,
- ctx::Json option)
-{
- ctx::inactive_detector_storage *handle = new(std::nothrow) ctx::inactive_detector_storage();
- IF_FAIL_RETURN_TAG(handle, ERR_OPERATION_FAILED, _E, "Memory allocation failed");
-
- int err = handle->read(subject, option);
- if (err != ERR_NONE) {
- delete handle;
- return err;
- }
-
- return ERR_NONE;
-}
-
-ctx::Json ctx::inactive_detector::to_json(std::vector<app_t> *app_infos)
-{
- ctx::Json data;
-
- for(std::vector<app_t>::iterator app_info = app_infos->begin();
- app_info != app_infos->end(); app_info++)
- {
- ctx::Json app_j;
- app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME, app_info->package_name);
- app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY, app_info->is_nodisplay);
- app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED, app_info->is_enabled);
- app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT, app_info->is_atboot);
- app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED, app_info->is_preloaded);
- app_j.set(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_TIMESTAMP, app_info->timestamp);
- }
- return data;
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_INACTIVE_DETECTOR_H__
-#define __CONTEXT_INACTIVE_DETECTOR_H__
-
-#include <string>
-#include <Json.h>
-#include <vector>
-#include "app_inactive_detector_types.h"
-#include <TimerManager.h>
-
-namespace ctx {
-
- class inactive_detector : public ITimerListener {
- private:
- int timer_id;
- TimerManager timer_mgr;
- public:
- inactive_detector();
- ~inactive_detector();
-
- int read(const char *subject,
- ctx::Json option);
-
- int update_clusters();
- void on_cluster_update_finished(
- std::vector<app_t> *apps_classified,
- int error);
- ctx::Json to_json(std::vector<app_t> *apps);
-
- bool onTimerExpired(int timerId);
- }; /* class inactive_detector */
-
-} /* namespace ctx */
-
-
-#endif /* __CONTEXT_INACTIVE_DETECTOR_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <Types.h>
-#include "inactive_detector.h"
-#include "app_inactive_detector_types.h"
-#include "inactive_detector_classificator.h"
-#include "inactive_detector_classificator_kmeans.h"
-
-int ctx::inactive_detector_classificator::classify(std::vector<app_t> *apps_with_weights)
-{
- inactive_detector_classificator_kmeans kmeans;
- int error = kmeans.classify(apps_with_weights);
-
- return error;
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_H__
-#define __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_H__
-
-#include <vector>
-#include "app_inactive_detector_types.h"
-#include <Json.h>
-
-namespace ctx {
-
- class inactive_detector_classificator
- {
- public:
- inactive_detector_classificator();
- ~inactive_detector_classificator();
-
- int classify(std::vector<app_t> *apps_with_weights);
- }; /* class inactive_detector_classificator */
-
-} /* namespace ctx */
-
-#endif /* __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <Types.h>
-#include "app_inactive_detector_types.h"
-#include "inactive_detector_classificator_kmeans.h"
-#include "inactive_detector_classificator_kmeans_types.h"
-#include <math.h>
-#include <stdlib.h>
-
-double ctx::inactive_detector_classificator_kmeans::randomf(double x)
-{
- return x * rand() / (RAND_MAX - 1.);
-}
-
-double ctx::inactive_detector_classificator_kmeans::glide_function(double x)
-{
- double value = sqrt(log(x) + 1);
- return (value > 0 ? value : 0);
-}
-
-point_s *ctx::inactive_detector_classificator_kmeans::reproject_to_2d(std::vector<app_t> *apps_with_weights)
-{
- int distr_size = apps_with_weights->size();
- point_s *p = new point_s[distr_size];
-
- int i=0;
- for(std::vector<app_t>::iterator apps_with_weight = apps_with_weights->begin();
- apps_with_weight != apps_with_weights->end(); apps_with_weight++)
- {
- point_s the_point;
-
- the_point.x = glide_function(apps_with_weight->weight); // normalize weight values
- the_point.y = 0; //remove 3rd dimension of the data
- the_point.origin_id = apps_with_weight->package_name;
-
- p[i] = the_point;
- i++;
- }
-
- return p;
-}
-
-bool ctx::inactive_detector_classificator_kmeans::annotate_data(std::vector<app_t> *apps_with_weights, point_s *c)
-{
- int i=0, max_group=-1;
-
- for(std::vector<app_t>::iterator apps_with_weight = apps_with_weights->begin();
- apps_with_weight != apps_with_weights->end(); apps_with_weight++)
- {
- apps_with_weight->is_active = c[i].group;
- i++;
- max_group = c[i].group > max_group ? c[i].group : max_group;
- }
-
- return max_group == APP_INACTIVE_DETECTOR_KMEANS_CLUSTER_COUNT;
-}
-
-double ctx::inactive_detector_classificator_kmeans::distance_to(point_s *p_from,
- point_s *p_to)
-{
- double x = p_from->x - p_to->x, y = p_from->y - p_to->y;
- return x*x + y*y;
-}
-
-int ctx::inactive_detector_classificator_kmeans::nearest(point_s *pt,
- point_s *centers,
- int cluster_number,
- double *distance)
-{
- int i;
- int min_i = pt->group;
- point_s *c;
-
- double d;
- double min_d = HUGE_VAL;
-
- for_n {
- if (min_d >(d = distance_to(c, pt))) {
- min_d = d; min_i = i;
- }
- }
-
- if (distance) *distance = min_d;
- return min_i;
-}
-
-void ctx::inactive_detector_classificator_kmeans::kpp(point_s *points, int length, point_s *centers, int cluster_number)
-{
- int j;
- int n_cluster;
- double sum;
- double *d = new double[length];
-
- point_s *p;
- centers[0] = points[rand() % length];
- for (n_cluster = 1; n_cluster < cluster_number; n_cluster++) {
- sum = 0;
- for_len{
- nearest(p, centers, n_cluster, d + j);
- sum += d[j];
- }
- sum = randomf(sum);
- for_len{
- if ((sum -= d[j]) > 0) continue;
- centers[n_cluster] = points[j];
- break;
- }
- }
- for_len p->group = nearest(p, centers, n_cluster, 0);
-
- delete d;
-}
-
-point_s *ctx::inactive_detector_classificator_kmeans::lloyd(point_s *points, int length, int cluster_number)
-{
- int i, j, min_i;
- int changed;
-
- point_s *centers = new point_s;
- point_s *p, *c;
-
- /* k++ init */
- kpp(points, length, centers, cluster_number);
-
- do {
- /* group element for centroids are used as counters */
- for_n{ c->group = 0; c->x = c->y = 0; }
- for_len{
- c = centers + p->group;
- c->group++;
- c->x += p->x; c->y += p->y;
- }
- for_n{ c->x /= c->group; c->y /= c->group; }
-
- changed = 0;
- /* find closest centroid of each point */
- for_len{
- min_i = nearest(p, centers, cluster_number, 0);
- if (min_i != p->group) {
- changed++;
- p->group = min_i;
- }
- }
- } while (changed > (length >> 10)); /* stop when 99.9% of points are good */
-
- for_n{ c->group = i; }
-
- return centers;
-}
-
-int ctx::inactive_detector_classificator_kmeans::classify(std::vector<app_t> *apps_with_weights)
-{
- //array of generated points
- point_s *v = reproject_to_2d(apps_with_weights);
- //mark cluster for each point, output centers
- point_s *c = lloyd(v, apps_with_weights->size(), APP_INACTIVE_DETECTOR_KMEANS_CLUSTER_COUNT);
- //append the result to input data
- bool classification_is_success = annotate_data(apps_with_weights, c);
-
- return classification_is_success ? ERR_NONE : ERR_OPERATION_FAILED;
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_H__
-#define __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_H__
-
-#include <vector>
-#include "inactive_detector_classificator_kmeans_types.h"
-#include <Json.h>
-
-namespace ctx {
-
- #define for_n for (c = centers, i = 0; i < cluster_number; i++, c++)
- #define for_len for (j = 0, p = points; j < length; j++, p++)
-
- class inactive_detector_classificator_kmeans
- {
- private:
- double randomf(double x);
- double glide_function(double x);
- point_s *reproject_to_2d(std::vector<app_t> *apps_with_weights);
- bool annotate_data(std::vector<app_t> *apps_with_weights, point_s *c);
-
- double distance_to(point_s *p_from, point_s *p_to);
- int nearest(point_s *pt, point_s *centers, int cluster_number, double *distance);
- void kpp(point_s *points, int length, point_s *centers, int centers_count);
- point_s *lloyd(point_s *points, int length, int cluster_number);
- public:
- inactive_detector_classificator_kmeans();
- ~inactive_detector_classificator_kmeans();
-
- int classify(std::vector<app_t> *apps_with_weights);
- }; /* class inactive_detector_classificator_kmeans */
-} /* namespace ctx */
-
-#endif /* __CONTEXT_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_APP_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_TYPES__
-#define __CONTEXT_APP_INACTIVE_DETECTOR_CLASSIFICATOR_KMEANS_TYPES__
-
-#define APP_INACTIVE_DETECTOR_KMEANS_CLUSTER_COUNT 2
-
-typedef struct {
- std::string origin_id;
- double x;
- double y;
- int group;
-} point_s;
-
-#endif
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <sstream>
-#include <ctime>
-#include <string>
-#include <memory>
-#include <Types.h>
-#include "inactive_detector.h"
-#include "inactive_detector_storage.h"
-#include "inactive_detector_storage_queries.h"
-#include "inactive_detector_classificator.h"
-#include "app_inactive_detector_types.h"
-
-/*int ctx::inactive_detector_storage::create_table()
-{
- bool ret = __dbManager.createTable(0, WIFI_TABLE_NAME, WIFI_CREATE_TABLE_COLUMNS, NULL, NULL);
- _D("Table Creation Request: %s", ret ? "SUCCESS" : "FAIL");
- return ret;
-}*/
-
-
-
-// expected Json format example: {timeframe: 1; is_active: 0}
-int ctx::inactive_detector_storage::read(
- const char *subject,
- ctx::Json filter)
-{
- std::string query;
- query = query_get_apps(subject, filter);
-
- IF_FAIL_RETURN(!query.empty(), ERR_OPERATION_FAILED);
-
- bool ret = __dbManager.execute(
- STR_EQ(subject, APP_INACTIVE_SUBJ_GET_APPS_INACTIVE) ?
- APP_INACTIVE_QUERY_ID_GET_APPS_INACTIVE :
- APP_INACTIVE_QUERY_ID_GET_APPS_ACTIVE,
- query.c_str(),
- this);
-
- IF_FAIL_RETURN(ret, ERR_OPERATION_FAILED);
-
- return ERR_NONE;
-}
-
-std::string ctx::inactive_detector_storage::query_get_apps(const char *subject, ctx::Json filter)
-{
- double timeframe;
- int is_active;
-
- std::string query(GET_APP_INFO_INACTIVE_QUERY);
- std::string placeholder_timeframe(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME);
- std::string placeholder_is_active(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_CLUSTER);
-
- filter.get(NULL, APP_INACTIVE_DETECTOR_DATA_TIMEFRAME, &timeframe);
- filter.get(NULL, APP_INACTIVE_DETECTOR_DATA_ISACTIVE, &is_active);
-
- std::stringstream timeframe_stream;
- timeframe_stream << timeframe;
-
- std::stringstream is_active_stream;
- is_active_stream << is_active;
-
- inject_params(query, placeholder_timeframe, timeframe_stream.str());
- inject_params(query, placeholder_is_active, is_active_stream.str());
-
- return query;
-}
-
-std::string ctx::inactive_detector_storage::query_update_apps(std::vector<app_t> *apps_with_weights)
-{
- std::string delete_query(DELETE_APP_ACTIVITY_CLASSIFIED_BY_TIMEFRAME);
- std::string insert_query(INSERT_APP_ACTIVITY_CLASSIFIED);
- std::string placeholder_timeframe(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME);
- std::string placeholder_values(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_VALUES);
- std::string placeholder_is_active(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_CLUSTER);
-
- std::stringstream timeframe_stream;
- timeframe_stream << apps_with_weights->front().timeframe;
-
- inject_params(delete_query, placeholder_timeframe, timeframe_stream.str());
- inject_params(insert_query, placeholder_values, subquery_form_values(apps_with_weights));
-
- std::stringstream result;
- result << delete_query << insert_query;
- return result.str();
-}
-
-// foreach app_info id+cluster -> select for insert
-std::string ctx::inactive_detector_storage::subquery_form_values(std::vector<app_t> *apps_with_weights)
-{
- std::stringstream select_elements;
-
- for(std::vector<app_t>::iterator row = apps_with_weights->begin();
- row != apps_with_weights->end(); row++)
- {
- //SELECT 1 as is_active, 1 as timeframe, 3964 as context_app_info_id
- std::stringstream select_element;
- select_element << " SELECT " << row->is_active << " as ";
- select_element << APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE;
- select_element << ", " << row->timeframe << " as ";
- select_element << APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME;
- select_element << ", " << row->id << " as ";
- select_element << APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID;
-
- if ((row != apps_with_weights->end()) && (row == --apps_with_weights->end()))
- select_element << " UNION ";
-
- select_elements << select_element;
- }
-
- return select_elements.str();
-}
-
-void ctx::inactive_detector_storage::json_to_object(std::vector<Json>& records,
- std::vector<app_t> *apps_with_weights, bool result_mode)
-{
- for(std::vector<Json>::iterator row = records.begin();
- row != records.end(); row++)
- {
- app_t app_with_weight;
- if (result_mode)
- {
- row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME,
- &app_with_weight.package_name);
- row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY,
- &app_with_weight.is_nodisplay);
- row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED,
- &app_with_weight.is_enabled);
- row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT,
- &app_with_weight.is_atboot);
- row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED,
- &app_with_weight.is_preloaded);
- row->get(NULL, APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT,
- &app_with_weight.weight);
- }
- else
- {
- row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID,
- &app_with_weight.id);
- row->get(NULL, APP_INACTIVE_DETECTOR_APPINFO_COLUMN_TIMESTAMP,
- &app_with_weight.timestamp);
- row->get(NULL, APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT,
- &app_with_weight.weight);
- row->get(NULL, APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE,
- &app_with_weight.is_active);
- }
-
- apps_with_weights->push_back(app_with_weight);
- }
-}
-
-void ctx::inactive_detector_storage::onExecuted(unsigned int query_id,
- int error,
- std::vector<Json>& records)
-{
- if (error != ERR_NONE) {
- _E("query_id:%d, error:%d", query_id, error);
- return;
- }
-
- std::vector<app_t> *apps_with_weights = NULL;
- if (query_id == APP_INACTIVE_QUERY_ID_GET_APPS_INACTIVE ||
- query_id == APP_INACTIVE_QUERY_ID_GET_APPS_ACTIVE)
- {
- json_to_object(records, apps_with_weights, TRUE);
- }
- else if (query_id == APP_INACTIVE_QUERY_ID_GET_APPS_WEIGHT) {
-
- json_to_object(records, apps_with_weights, FALSE);
-
- if (apps_with_weights->size() > 0) {
- inactive_detector_classificator i_detector_classificator;
- int _error = i_detector_classificator.classify(apps_with_weights);
-
- if(_error == ERR_NONE)
- {
- std::string query;
- query = query_update_apps(apps_with_weights);
- bool ret = __dbManager.execute(APP_INACTIVE_QUERY_ID_UPDATE_CLUSTERS,
- query.c_str(),
- this);
- _D("load visits execute query result: %s", ret ? "SUCCESS" : "FAIL");
- }
- else
- {
- _E("classification query_id:%d, error:%d",
- query_id, _error);
- }
- }
- }
- else if (query_id == APP_INACTIVE_QUERY_ID_UPDATE_CLUSTERS) {
- _D("UPDATE_CLUSTERS execute query id: %d", query_id);
- }
- else {
- _E("unknown query_id:%d", query_id);
- }
-}
-
-void ctx::inactive_detector_storage::inject_params(std::string& str, const std::string& from, const std::string& to)
-{
- if(from.empty())
- return;
- size_t start_pos = 0;
- while((start_pos = str.find(from, start_pos)) != std::string::npos) {
- str.replace(start_pos, from.length(), to);
- start_pos += to.length();
- }
-}
-
-// normalzie weights
-int ctx::inactive_detector_storage::update_ranks()
-{
- return ERR_NONE;
-}
-
-int ctx::inactive_detector_storage::get_apps_info_w_weights(
- double timestamp_from)
-{
- std::stringstream timestamp_stream;
- timestamp_stream << timestamp_from;
- std::string timestamp_str = timestamp_stream.str();
-
- std::string query(GET_APP_INFO_W_WEIGHT_QUERY);
- std::string placeholder(APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMESTAMP);
-
- inject_params(query, placeholder, timestamp_str);
-
- bool ret = __dbManager.execute(APP_INACTIVE_QUERY_ID_GET_APPS_WEIGHT,
- query.c_str(),
- this);
- _D("load visits execute query result: %s", ret ? "SUCCESS" : "FAIL");
-
- return ERR_NONE ;
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_INACTIVE_DETECTOR_STORAGE_H__
-#define __CONTEXT_INACTIVE_DETECTOR_STORAGE_H__
-
-#include <vector>
-#include "app_inactive_detector_types.h"
-#include <Json.h>
-#include <DatabaseManager.h>
-
-namespace ctx {
-
- class inactive_detector_storage : public IDatabaseListener
- {
- private:
- //int type; //TODO: enum
- void inject_params(std::string& str,
- const std::string& from,
- const std::string& to);
-
- void json_to_object(std::vector<Json>& records,
- std::vector<app_t> *apps_with_weights, bool result_mode);
-
- std::string query_get_apps(const char *subject,
- ctx::Json filter);
-
- std::string query_update_apps(std::vector<app_t> *apps_with_weights);
-
- std::string subquery_form_values(std::vector<app_t> *apps_with_weights);
-
- void onTableCreated(unsigned int query_id, int error) {}
- void onInserted(unsigned int query_id, int error, int64_t row_id) {}
- void onExecuted(unsigned int query_id, int error, std::vector<Json>& records);
-
- DatabaseManager __dbManager;
-
- public:
- inactive_detector_storage();
- ~inactive_detector_storage();
-
- int read(const char *subject,
- ctx::Json filter);
-
- int update_ranks();
- int get_apps_info_w_weights(double timestamp_from);
- }; /* class inactive_detector_storage */
-
-} /* namespace ctx */
-
-#endif /* __CONTEXT_INACTIVE_DETECTOR_STORAGE_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_INACTIVE_DETECTOR_STORAGE_QUERIES_H__
-#define __CONTEXT_INACTIVE_DETECTOR_STORAGE_QUERIES_H__
-
-#include <vector>
-#include "app_inactive_detector_types.h"
-
-/*
-
---1 calculate weights
-SELECT
- app_info._id,
- app_info.package_name,
- app_info.is_nodisplay,
- app_info.is_enabled,
- app_info.is_atboot,
- app_info.is_preloaded,
- app_info.timestamp,
-
- app_hist_g.weight as weight
-FROM
- context_app_info app_info
-
-INNER JOIN
-
- (SELECT
- distinct package_name ,
- IFNULL((select count(package_name) from context_app_launch_log
- where package_name == app_hist.package_name AND timestamp> 8640412900), 0 )
- *
- IFNULL((select sum(duration) from context_app_launch_log
- where package_name == app_hist.package_name AND timestamp> 8640412900) , 0)
- as weight
-
- FROM context_app_launch_log app_hist
-)app_hist_g
-
-ON app_hist_g.package_name
-=
-app_info.package_name
-
-ORDER BY app_hist_g.weight
-
-*/
-
-#define GET_APP_INFO_W_WEIGHT_QUERY "SELECT "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_TYPE ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_TIMESTAMP ", "\
- ""\
- " " APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT \
- ""\
- " FROM " APP_INACTIVE_DETECTOR_APPINFO_TABLE " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS \
- ""\
- " INNER JOIN " \
- " (SELECT "\
- " DISTINCT " APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME "," \
- " IFNULL((SELECT COUNT(" APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME ")" \
- " FROM " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE \
- " WHERE " APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME "==" APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME \
- " AND " \
- " " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_TIMESTAMP " >= " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMESTAMP \
- "), 0) " \
- " * " \
- " IFNULL((SELECT SUM(" APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_DURATION ")" \
- " FROM " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE \
- " WHERE " APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME "==" APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME \
- " AND " \
- " " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_COLUMN_TIMESTAMP " >= " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMESTAMP \
- ""\
- "), 0) " \
- " as " APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT \
- " FROM " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE " " APP_INACTIVE_DETECTOR_APPLAUNCH_LOG_TABLE_ALIAS \
- ") " APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS \
- " ON " APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME \
- " = " \
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME \
- " ORDER BY " APP_INACTIVE_DETECTOR_VIRTUAL_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_VIRTUAL_COLUMN_WEIGHT
-
-/*
---2 select inner join context_app_info
-SELECT
- app_info.package_name,
- app_info.is_nodisplay,
- app_info.is_enabled,
- app_info.is_atboot,
- app_info.is_preloaded,
-
- activity_classified.activity_rate
-
-FROM
- context_activity_classified activity_classified
-INNER JOIN
- context_app_info app_info
-ON activity_classified.context_app_info_id = app_info._id
-
-WHERE
- activity_classified.is_active = 1
- AND
- activity_classified.timeframe = 1
-*/
-
-#define GET_APP_INFO_INACTIVE_QUERY "SELECT "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_PACKAGE_NAME ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_NODISPLAY ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ENABLED ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_ATBOOT ", "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_IS_PRELOADED ", "\
- " "\
- " " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_ACTIVITY_RATE " "\
- " FROM "\
- " " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE " " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS " "\
- " INNER JOIN "\
- " " APP_INACTIVE_DETECTOR_APPINFO_TABLE " " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS " "\
- " ON " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID ""\
- " = " APP_INACTIVE_DETECTOR_APPINFO_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_APPINFO_COLUMN_ID " "\
- " WHERE "\
- APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE ""\
- " = " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_CLUSTER ""\
- " AND "\
- " " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE_ALIAS "." APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME ""\
- " = " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME ""
-
-/*
---3 update ranks and clusters for each timeframe: delete all for each time frame, add new calculations for apps
-DELETE FROM
- context_activity_classified
-WHERE
- timeframe = 1
-*/
-
-#define DELETE_APP_ACTIVITY_CLASSIFIED_BY_TIMEFRAME "DELETE FROM "\
- APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE \
- " WHERE "\
- " timeframe = " APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_TIMEFRAME
-
-
-/*INSERT INTO
- context_activity_classified
- (is_active,
- timeframe,
- context_app_info_id)
-SELECT
- is_active,
- timeframe,
- context_app_info_id
-FROM --make loop
- (
- SELECT 1 as is_active, 1 as timeframe, 3964 as context_app_info_id
- UNION
- SELECT 0 as is_active, 1 as timeframe, 3964 as context_app_info_id
- ) q
-*/
-
-#define INSERT_APP_ACTIVITY_CLASSIFIED " INSERT INTO "\
- APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_TABLE \
- "( " APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE ", "\
- APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME ", "\
- APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID ")" \
-"SELECT " \
- APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_IS_ACTIVE "," \
- APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_TIMEFRAME ", "\
- APP_INACTIVE_DETECTOR_ACTIVITYCLASSIFIED_COLUMN_CONTEXT_APP_INFO_ID \
-"FROM"\
- "(" \
- APP_INACTIVE_DETECTOR_VALUE_PLACEHOLDER_VALUES \
- ") q"
-
-
-
-#endif /* __CONTEXT_INACTIVE_DETECTOR_STORAGE_QUERIES_H__ */
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <Types.h>
-#include "inactive_detector_weight.h"
-#include "inactive_detector_storage.h"
-
-
-int ctx::inactive_detector_weight::request_weights(
- double timestamp_from)
-{
- inactive_detector_storage ids;
- // query the database for the result
- int error = ids.get_apps_info_w_weights(timestamp_from);
-
- return error;
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONTEXT_INACTIVE_DETECTOR_WEIGHT_H__
-#define __CONTEXT_INACTIVE_DETECTOR_WEIGHT_H__
-
-// #include <string>
-// #include <sstream>
-
-namespace ctx {
-
- class inactive_detector_weight {
- public:
- inactive_detector_weight() {};
- ~inactive_detector_weight() {};
- int request_weights(double timestamp_from);// {};
- }; /* class inactive_detector_weight */
-
-} /* namespace ctx */
-
-#endif /* __CONTEXT_INACTIVE_DETECTOR_WEIGHT_H__ */
\ No newline at end of file
projects / platform / core / context / context-provider.git / commitdiff