--- /dev/null
+/*
+ * Copyright (c) 2017 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 <activity_recognition.h>
+
+#include <ContextTypes.h>
+#include <JobSchedulerTypesPrivate.h>
+#include <job_scheduler_types_internal.h>
+#include "../ContextPublisher.h"
+#include "../IContextObserver.h"
+
+using namespace ctx;
+
+namespace {
+ class UserActivity : public ContextPublisher {
+ public:
+ virtual ~UserActivity();
+
+ virtual const char* getUri() const = 0;
+
+ bool isReadable() const;
+
+ protected:
+ UserActivity();
+
+ void read();
+ void subscribe();
+ void unsubscribe();
+ void publish(activity_data_h event);
+
+ virtual activity_type_e getActivityType() const = 0;
+ virtual activity_recognition_cb getCallback() const = 0;
+
+ private:
+ activity_h __handle;
+ };
+
+ class ActivityStationary : public UserActivity {
+ public:
+ ActivityStationary(uid_t uid);
+ ~ActivityStationary();
+
+ const char* getUri() const;
+
+ protected:
+ activity_type_e getActivityType() const;
+ activity_recognition_cb getCallback() const;
+
+ private:
+ static void __activityCb(activity_type_e activity,
+ const activity_data_h data, double timestamp, activity_error_e error, void *userData);
+ };
+
+ class ActivityWalking : public UserActivity {
+ public:
+ ActivityWalking(uid_t uid);
+ ~ActivityWalking();
+
+ const char* getUri() const;
+
+ protected:
+ activity_type_e getActivityType() const;
+ activity_recognition_cb getCallback() const;
+
+ private:
+ static void __activityCb(activity_type_e activity,
+ const activity_data_h data, double timestamp, activity_error_e error, void *userData);
+ };
+
+ class ActivityRunning : public UserActivity {
+ public:
+ ActivityRunning(uid_t uid);
+ ~ActivityRunning();
+
+ const char* getUri() const;
+
+ protected:
+ activity_type_e getActivityType() const;
+ activity_recognition_cb getCallback() const;
+
+ private:
+ static void __activityCb(activity_type_e activity,
+ const activity_data_h data, double timestamp, activity_error_e error, void *userData);
+ };
+
+ class ActivityInVehicle : public UserActivity {
+ public:
+ ActivityInVehicle(uid_t uid);
+ ~ActivityInVehicle();
+
+ const char* getUri() const;
+
+ protected:
+ activity_type_e getActivityType() const;
+ activity_recognition_cb getCallback() const;
+
+ private:
+ static void __activityCb(activity_type_e activity,
+ const activity_data_h data, double timestamp, activity_error_e error, void *userData);
+ };
+}
+
+REGISTER_PUBLISHER_FULL(__create_stationary, URI(STATIONARY), ActivityStationary)
+REGISTER_PUBLISHER_FULL(__create_walking, URI(WALKING), ActivityWalking)
+REGISTER_PUBLISHER_FULL(__create_running, URI(RUNNING), ActivityRunning)
+REGISTER_PUBLISHER_FULL(__create_in_vehicle, URI(IN_VEHICLE), ActivityInVehicle)
+
+UserActivity::UserActivity() :
+ __handle(NULL)
+{
+}
+
+UserActivity::~UserActivity()
+{
+}
+
+bool UserActivity::isReadable() const
+{
+ return false;
+}
+
+void UserActivity::read()
+{
+}
+
+void UserActivity::subscribe()
+{
+ activity_create(&__handle);
+ activity_start_recognition(__handle, getActivityType(), getCallback(), this);
+}
+
+void UserActivity::unsubscribe()
+{
+ if (__handle) {
+ activity_stop_recognition(__handle);
+ activity_release(__handle);
+ __handle = NULL;
+ }
+}
+
+void UserActivity::publish(activity_data_h event)
+{
+ __data[NAME(EVENT)] = VALUE(DETECTED);
+
+ activity_accuracy_e accuracy = ACTIVITY_ACCURACY_LOW;
+ activity_get_accuracy(event, &accuracy);
+
+ switch (accuracy) {
+ case ACTIVITY_ACCURACY_HIGH:
+ __data[NAME(ACCURACY)] = VALUE(HIGH);
+ break;
+ case ACTIVITY_ACCURACY_MID:
+ __data[NAME(ACCURACY)] = VALUE(NORMAL);
+ break;
+ default:
+ __data[NAME(ACCURACY)] = VALUE(LOW);
+ break;
+ }
+
+ notifyObservers();
+}
+
+
+ActivityStationary::ActivityStationary(uid_t uid)
+{
+ bool supported = false;
+ activity_is_supported(ACTIVITY_STATIONARY, &supported);
+ IF_FAIL_THROW(supported, E_SUPPORT);
+ _D("Created");
+}
+
+ActivityStationary::~ActivityStationary()
+{
+ unsubscribe();
+ _D("Destroyed");
+}
+
+const char* ActivityStationary::getUri() const
+{
+ return URI(STATIONARY);
+}
+
+activity_type_e ActivityStationary::getActivityType() const
+{
+ return ACTIVITY_STATIONARY;
+}
+
+activity_recognition_cb ActivityStationary::getCallback() const
+{
+ return __activityCb;
+}
+
+void ActivityStationary::__activityCb(activity_type_e activity, const activity_data_h data, double timestamp, activity_error_e error, void *userData)
+{
+ IF_FAIL_VOID(error == ACTIVITY_ERROR_NONE);
+ static_cast<ActivityStationary*>(userData)->publish(data);
+}
+
+
+ActivityWalking::ActivityWalking(uid_t uid)
+{
+ bool supported = false;
+ activity_is_supported(ACTIVITY_WALK, &supported);
+ IF_FAIL_THROW(supported, E_SUPPORT);
+ _D("Created");
+}
+
+ActivityWalking::~ActivityWalking()
+{
+ unsubscribe();
+ _D("Destroyed");
+}
+
+const char* ActivityWalking::getUri() const
+{
+ return URI(WALKING);
+}
+
+activity_type_e ActivityWalking::getActivityType() const
+{
+ return ACTIVITY_WALK;
+}
+
+activity_recognition_cb ActivityWalking::getCallback() const
+{
+ return __activityCb;
+}
+
+void ActivityWalking::__activityCb(activity_type_e activity, const activity_data_h data, double timestamp, activity_error_e error, void *userData)
+{
+ IF_FAIL_VOID(error == ACTIVITY_ERROR_NONE);
+ static_cast<ActivityWalking*>(userData)->publish(data);
+}
+
+
+ActivityRunning::ActivityRunning(uid_t uid)
+{
+ bool supported = false;
+ activity_is_supported(ACTIVITY_RUN, &supported);
+ IF_FAIL_THROW(supported, E_SUPPORT);
+ _D("Created");
+}
+
+ActivityRunning::~ActivityRunning()
+{
+ unsubscribe();
+ _D("Destroyed");
+}
+
+const char* ActivityRunning::getUri() const
+{
+ return URI(RUNNING);
+}
+
+activity_type_e ActivityRunning::getActivityType() const
+{
+ return ACTIVITY_RUN;
+}
+
+activity_recognition_cb ActivityRunning::getCallback() const
+{
+ return __activityCb;
+}
+
+void ActivityRunning::__activityCb(activity_type_e activity, const activity_data_h data, double timestamp, activity_error_e error, void *userData)
+{
+ IF_FAIL_VOID(error == ACTIVITY_ERROR_NONE);
+ static_cast<ActivityRunning*>(userData)->publish(data);
+}
+
+
+ActivityInVehicle::ActivityInVehicle(uid_t uid)
+{
+ bool supported = false;
+ activity_is_supported(ACTIVITY_IN_VEHICLE, &supported);
+ IF_FAIL_THROW(supported, E_SUPPORT);
+ _D("Created");
+}
+
+ActivityInVehicle::~ActivityInVehicle()
+{
+ unsubscribe();
+ _D("Destroyed");
+}
+
+const char* ActivityInVehicle::getUri() const
+{
+ return URI(IN_VEHICLE);
+}
+
+activity_type_e ActivityInVehicle::getActivityType() const
+{
+ return ACTIVITY_IN_VEHICLE;
+}
+
+activity_recognition_cb ActivityInVehicle::getCallback() const
+{
+ return __activityCb;
+}
+
+void ActivityInVehicle::__activityCb(activity_type_e activity, const activity_data_h data, double timestamp, activity_error_e error, void *userData)
+{
+ IF_FAIL_VOID(error == ACTIVITY_ERROR_NONE);
+ static_cast<ActivityInVehicle*>(userData)->publish(data);
+}
projects / platform / core / context / job-scheduler.git / commitdiff