public void StartGeneratingTestData(MotionActivityType type, TimeSpan interval, MotionActivityConfidence?confidence = null)
        {
            if (this.generating != null)
            {
                throw new ArgumentException("Manager is already generating test data");
            }

            this.GeneratingActivityType = type;
            this.GeneratingConfidence   = confidence ?? MotionActivityConfidence.High;
            this.GeneratingInterval     = interval;

            this.generating = Observable
                              .Interval(interval)
                              .Subscribe(x =>
            {
                var e = new MotionActivityEvent(
                    type,
                    MotionActivityConfidence.High,
                    DateTimeOffset.Now
                    );
                lock (this.EventData)
                    this.EventData.Add(e);

                this.ActivitySubject.OnNext(e);
            });
        }
Esempio n. 2
0
 public MotionActivityEvent(MotionActivityType types, MotionActivityConfidence confidence, DateTimeOffset timestamp)
 {
     this.Types      = types;
     this.Confidence = confidence;
     this.Timestamp  = timestamp;
 }
Esempio n. 3
0
        //public static async Task<IList<MotionActivityTimeBlock>> GetTimeBlocksForRange(this IMotionActivity activity,
        //                                                                               DateTimeOffset start,
        //                                                                               DateTimeOffset? end = null,
        //                                                                               MotionActivityConfidence minConfidence = MotionActivityConfidence.Medium)
        //{
        //    var list = new List<MotionActivityTimeBlock>();
        //    var result = await activity.Query(start, end);
        //    var set = result
        //        .Where(x => x.Confidence >= minConfidence)
        //        .OrderBy(x => x.Timestamp)
        //        .ToList();

        //    if (set.Count > 1)
        //    {
        //        MotionActivityEvent firstEvent = null;
        //        foreach (var item in set)
        //        {
        //            if (firstEvent == null)
        //                firstEvent = item;
        //            else if (!firstEvent.Types.HasFlag(item.Types)) // has to have 1 of the types
        //            {
        //                var block = new MotionActivityTimeBlock(item.Types, firstEvent.Timestamp, item.Timestamp);
        //                list.Add(block);

        //                // first event of next time block
        //                firstEvent = item;
        //            }

        //        }
        //    }

        //    return list;
        //}


        //public static async Task<IDictionary<MotionActivityType, TimeSpan>> GetTotalsForRange(this IMotionActivity activity,
        //                                                                                      DateTimeOffset start,
        //                                                                                      DateTimeOffset? end = null,
        //                                                                                      MotionActivityConfidence minConfidence = MotionActivityConfidence.Medium)
        //{
        //    var dict = new Dictionary<MotionActivityType, TimeSpan>();
        //    var result = await activity.Query(start, end);
        //    var set = result
        //        .Where(x => x.Confidence >= minConfidence)
        //        .OrderBy(x => x.Timestamp)
        //        .ToList();

        //    if (set.Count > 1)
        //    {
        //        MotionActivityEvent lastEvent = null;
        //        foreach (var item in set)
        //        {
        //            if (lastEvent == null)
        //                lastEvent = item;
        //            else
        //            {
        //                if (!dict.ContainsKey(item.Types))
        //                    dict.Add(item.Types, TimeSpan.Zero);

        //                var ts = item.Timestamp.Subtract(lastEvent.Timestamp);
        //                dict[item.Types] += ts;
        //            }

        //        }
        //    }
        //    return dict;
        //}


        /// <summary>
        /// Queries for the most current event and checks against type & confidence
        /// </summary>
        /// <param name="activity"></param>
        /// <param name="type"></param>
        /// <param name="maxAge"></param>
        /// <param name="minConfidence"></param>
        /// <returns></returns>
        public static async Task <bool> IsCurrentActivity(this IMotionActivityManager activity, MotionActivityType type, TimeSpan?maxAge = null, MotionActivityConfidence minConfidence = MotionActivityConfidence.Medium)
        {
            var result = await activity.GetCurrentActivity(maxAge);

            //if (result == default(MotionActivityEvent))
            //return false;
            if (result.Confidence < minConfidence)
            {
                return(false);
            }

            return(result.Types.HasFlag(type));
        }
Esempio n. 4
0
 public MotionActivityTimeBlock(MotionActivityType type, DateTimeOffset start, DateTimeOffset end)
 {
     this.Type  = type;
     this.Start = start;
     this.End   = end;
 }