Subversion Repositories Projects



namespace GMap.NET

{

   using System;

   using System.Collections.Generic;

   using System.Diagnostics;

   using System.Globalization;

   using System.IO;

   using System.Net;

   using System.Text;

   using System.Threading;

   using System.Xml;

   using System.Xml.Serialization;

   using GMap.NET.CacheProviders;

   using GMap.NET.Internals;

   using GMap.NET.MapProviders;

    using System.Reflection;

#if PocketPC

   using OpenNETCF.ComponentModel;

   using OpenNETCF.Threading;

   using Thread=OpenNETCF.Threading.Thread2;

#endif

   /// <summary>

   /// maps manager

   /// </summary>

   public class GMaps : Singleton<GMaps>

   {

      /// <summary>

      /// tile access mode

      /// </summary>

      public AccessMode Mode = AccessMode.ServerAndCache;

      /// <summary>

      /// is map ussing cache for routing

      /// </summary>

      public bool UseRouteCache = true;

      /// <summary>

      /// is map using cache for geocoder

      /// </summary>

      public bool UseGeocoderCache = true;

      /// <summary>

      /// is map using cache for directions

      /// </summary>

      public bool UseDirectionsCache = true;

      /// <summary>

      /// is map using cache for placemarks

      /// </summary>

      public bool UsePlacemarkCache = true;

      /// <summary>

      /// is map ussing cache for other url

      /// </summary>

      public bool UseUrlCache = true;

      /// <summary>

      /// is map using memory cache for tiles

      /// </summary>

      public bool UseMemoryCache = true;

      /// <summary>

      /// primary cache provider, by default: ultra fast SQLite!

      /// </summary>

      public PureImageCache PrimaryCache

      {

         get

         {

            return Cache.Instance.ImageCache;

         }

         set

         {

            Cache.Instance.ImageCache = value;

         }

      }

      /// <summary>

      /// secondary cache provider, by default: none,

      /// use it if you have server in your local network

      /// </summary>

      public PureImageCache SecondaryCache

      {

         get

         {

            return Cache.Instance.ImageCacheSecond;

         }

         set

         {

            Cache.Instance.ImageCacheSecond = value;

         }

      }

      /// <summary>

      /// MemoryCache provider

      /// </summary>

      public readonly MemoryCache MemoryCache = new MemoryCache();

      /// <summary>

      /// load tiles in random sequence

      /// </summary>

      public bool ShuffleTilesOnLoad = false;

      /// <summary>

      /// tile queue to cache

      /// </summary>

      readonly Queue<CacheQueueItem> tileCacheQueue = new Queue<CacheQueueItem>();

      bool? isRunningOnMono;

      /// <summary>

      /// return true if running on mono

      /// </summary>

      /// <returns></returns>

      public bool IsRunningOnMono

      {

         get

         {

            if(!isRunningOnMono.HasValue)

            {

               try

               {

                  isRunningOnMono = (Type.GetType("Mono.Runtime") != null);

                  return isRunningOnMono.Value;

               }

               catch

               {

               }

            }

            else

            {

               return isRunningOnMono.Value;

            }

            return false;

         }

      }

      /// <summary>

      /// cache worker

      /// </summary>

      Thread CacheEngine;

      internal readonly AutoResetEvent WaitForCache = new AutoResetEvent(false);

#if !PocketPC

      static GMaps()

      {

          if (GMapProvider.TileImageProxy == null)

          {

              try

              {

                  AppDomain d = AppDomain.CurrentDomain;

                  var AssembliesLoaded = d.GetAssemblies();

                  Assembly l = null;

                  foreach (var a in AssembliesLoaded)

                  {

                      if (a.FullName.Contains("GMap.NET.WindowsForms") || a.FullName.Contains("GMap.NET.WindowsPresentation"))

                      {

                          l = a;

                          break;

                      }

                  }

                  if (l == null)

                  {

                      var jj = Assembly.GetExecutingAssembly().Location;

                      var hh = Path.GetDirectoryName(jj);

                      var f1 = hh + Path.DirectorySeparatorChar + "GMap.NET.WindowsForms.dll";

                      var f2 = hh + Path.DirectorySeparatorChar + "GMap.NET.WindowsPresentation.dll";

                      if (File.Exists(f1))

                      {

                          l = Assembly.LoadFile(f1);

                      }

                      else if (File.Exists(f2))

                      {

                          l = Assembly.LoadFile(f2);

                      }

                  }

                  if (l != null)

                  {

                      Type t = null;

                      if (l.FullName.Contains("GMap.NET.WindowsForms"))

                      {

                          t = l.GetType("GMap.NET.WindowsForms.GMapImageProxy");

                      }

                      else if (l.FullName.Contains("GMap.NET.WindowsPresentation"))

                      {

                          t = l.GetType("GMap.NET.WindowsPresentation.GMapImageProxy");

                      }

                      if (t != null)

                      {

                          t.InvokeMember("Enable", BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, null);

                      }

                  }

              }

              catch (Exception ex)

              {

                  Debug.WriteLine("GMaps, try set TileImageProxy failed: " + ex.Message);

              }

          }

      }

#endif

      public GMaps()

      {

         #region singleton check

         if(Instance != null)

         {

            throw (new Exception("You have tried to create a new singleton class where you should have instanced it. Replace your \"new class()\" with \"class.Instance\""));

         }

         #endregion

         ServicePointManager.DefaultConnectionLimit = 5;

      }

#if !PocketPC

      /// <summary>

      /// triggers dynamic sqlite loading, 

      /// call this before you use sqlite for other reasons than caching maps

      /// </summary>

      public void SQLitePing()

      {

#if SQLite

#if !MONO

         SQLitePureImageCache.Ping();

#endif

#endif

      }

#endif

      #region -- Stuff --

#if !PocketPC

      /// <summary>

      /// exports current map cache to GMDB file

      /// if file exsist only new records will be added

      /// otherwise file will be created and all data exported

      /// </summary>

      /// <param name="file"></param>

      /// <returns></returns>

      public bool ExportToGMDB(string file)

      {

#if SQLite

         if(PrimaryCache is SQLitePureImageCache)

         {

            StringBuilder db = new StringBuilder((PrimaryCache as SQLitePureImageCache).GtileCache);

            db.AppendFormat(CultureInfo.InvariantCulture, "{0}{1}Data.gmdb", GMapProvider.LanguageStr, Path.DirectorySeparatorChar);

            return SQLitePureImageCache.ExportMapDataToDB(db.ToString(), file);

         }

#endif

         return false;

      }

      /// <summary>

      /// imports GMDB file to current map cache

      /// only new records will be added

      /// </summary>

      /// <param name="file"></param>

      /// <returns></returns>

      public bool ImportFromGMDB(string file)

      {

#if SQLite

         if(PrimaryCache is GMap.NET.CacheProviders.SQLitePureImageCache)

         {

            StringBuilder db = new StringBuilder((PrimaryCache as SQLitePureImageCache).GtileCache);

            db.AppendFormat(CultureInfo.InvariantCulture, "{0}{1}Data.gmdb", GMapProvider.LanguageStr, Path.DirectorySeparatorChar);

            return SQLitePureImageCache.ExportMapDataToDB(file, db.ToString());

         }

#endif

         return false;

      }

#if SQLite

      /// <summary>

      /// optimizes map database, *.gmdb

      /// </summary>

      /// <param name="file">database file name or null to optimize current user db</param>

      /// <returns></returns>

      public bool OptimizeMapDb(string file)

      {

         if(PrimaryCache is GMap.NET.CacheProviders.SQLitePureImageCache)

         {

            if(string.IsNullOrEmpty(file))

            {

               StringBuilder db = new StringBuilder((PrimaryCache as SQLitePureImageCache).GtileCache);

               db.AppendFormat(CultureInfo.InvariantCulture, "{0}{1}Data.gmdb", GMapProvider.LanguageStr, Path.DirectorySeparatorChar);

               return SQLitePureImageCache.VacuumDb(db.ToString());

            }

            else

            {

               return SQLitePureImageCache.VacuumDb(file);

            }

         }

         return false;

      }

#endif

#endif

      /// <summary>

      /// enqueueens tile to cache

      /// </summary>

      /// <param name="task"></param>

      void EnqueueCacheTask(CacheQueueItem task)

      {

         lock(tileCacheQueue)

         {

            if(!tileCacheQueue.Contains(task))

            {

               Debug.WriteLine("EnqueueCacheTask: " + task);

               tileCacheQueue.Enqueue(task);

               if(CacheEngine != null && CacheEngine.IsAlive)

               {

                  WaitForCache.Set();

               }

#if PocketPC

               else if(CacheEngine == null || CacheEngine.State == ThreadState.Stopped || CacheEngine.State == ThreadState.Unstarted)

#else

               else if(CacheEngine == null || CacheEngine.ThreadState == System.Threading.ThreadState.Stopped || CacheEngine.ThreadState == System.Threading.ThreadState.Unstarted)

#endif

               {

                  CacheEngine = null;

                  CacheEngine = new Thread(new ThreadStart(CacheEngineLoop));

                  CacheEngine.Name = "CacheEngine";

                  CacheEngine.IsBackground = false;

                  CacheEngine.Priority = ThreadPriority.Lowest;

                  abortCacheLoop = false;

                  CacheEngine.Start();

               }

            }

         }

      }

      volatile bool abortCacheLoop = false;

      internal volatile bool noMapInstances = false;

      public TileCacheComplete OnTileCacheComplete;

      public TileCacheStart OnTileCacheStart;

      public TileCacheProgress OnTileCacheProgress;

      /// <summary>

      /// immediately stops background tile caching, call it if you want fast exit the process

      /// </summary>

      public void CancelTileCaching()

      {

         Debug.WriteLine("CancelTileCaching...");

         abortCacheLoop = true;

         lock(tileCacheQueue)

         {

            tileCacheQueue.Clear();

            WaitForCache.Set();

         }

      }

      int readingCache = 0;      

      volatile bool cacheOnIdleRead = true;

      /// <summary>

      /// delays writing tiles to cache while performing reads

      /// </summary>

      public bool CacheOnIdleRead

      {

          get

          {

              return cacheOnIdleRead;

          }

          set

          {

              cacheOnIdleRead = value;

          }

      }

      volatile bool boostCacheEngine = false;

      /// <summary>

      /// disables delay between saving tiles into database/cache

      /// </summary>

      public bool BoostCacheEngine

      {

          get

          {

              return boostCacheEngine;

          }

          set

          {

              boostCacheEngine = value;

          }

      }

      /// <summary>

      /// live for cache ;}

      /// </summary>

      /// <param name="sender"></param>

      /// <param name="e"></param>

      void CacheEngineLoop()

      {

         Debug.WriteLine("CacheEngine: start");

         int left = 0;

         if(OnTileCacheStart != null)

         {

            OnTileCacheStart();

         }

         bool startEvent = false;

         while(!abortCacheLoop)

         {

            try

            {

               CacheQueueItem? task = null;

               lock(tileCacheQueue)

               {

                  left = tileCacheQueue.Count;

                  if(left > 0)

                  {

                     task = tileCacheQueue.Dequeue();

                  }

               }

               if(task.HasValue)

               {

                  if(startEvent)

                  {

                     startEvent = false;

                     if(OnTileCacheStart != null)

                     {

                        OnTileCacheStart();

                     }

                  }

                  if(OnTileCacheProgress != null)

                  {

                     OnTileCacheProgress(left);

                  }

                  #region -- save --

                  // check if stream wasn't disposed somehow

                  if(task.Value.Img != null)

                  {

                     Debug.WriteLine("CacheEngine[" + left + "]: storing tile " + task.Value + ", " + task.Value.Img.Length / 1024 + "kB...");

                     if((task.Value.CacheType & CacheUsage.First) == CacheUsage.First && PrimaryCache != null)

                     {

                        if(cacheOnIdleRead)

                        {

                           while(Interlocked.Decrement(ref readingCache) > 0)

                           {

                              Thread.Sleep(1000);

                           }

                        }

                        PrimaryCache.PutImageToCache(task.Value.Img, task.Value.Tile.Type, task.Value.Tile.Pos, task.Value.Tile.Zoom);

                     }

                     if((task.Value.CacheType & CacheUsage.Second) == CacheUsage.Second && SecondaryCache != null)

                     {

                        if(cacheOnIdleRead)

                        {

                           while(Interlocked.Decrement(ref readingCache) > 0)

                           {

                              Thread.Sleep(1000);

                           }

                        }

                        SecondaryCache.PutImageToCache(task.Value.Img, task.Value.Tile.Type, task.Value.Tile.Pos, task.Value.Tile.Zoom);

                     }

                     task.Value.Clear();

                     if(!boostCacheEngine)

                     {

#if PocketPC

                        Thread.Sleep(3333);

#else

                        Thread.Sleep(333);

#endif

                     }

                  }

                  else

                  {

                     Debug.WriteLine("CacheEngineLoop: skip, tile disposed to early -> " + task.Value);

                  }

                  task = null;

                  #endregion

               }

               else

               {

                  if(!startEvent)

                  {

                     startEvent = true;

                     if(OnTileCacheComplete != null)

                     {

                        OnTileCacheComplete();

                     }

                  }

                  if(abortCacheLoop || noMapInstances || !WaitForCache.WaitOne(33333, false) || noMapInstances)

                  {

                     break;

                  }

               }

            }

#if !PocketPC

            catch(AbandonedMutexException)

            {

               break;

            }

#endif

            catch(Exception ex)

            {

               Debug.WriteLine("CacheEngineLoop: " + ex.ToString());

            }

         }

         Debug.WriteLine("CacheEngine: stop");

         if(!startEvent)

         {

            if(OnTileCacheComplete != null)

            {

               OnTileCacheComplete();

            }

         }

      }

      class StringWriterExt : StringWriter

      {

         public StringWriterExt(IFormatProvider info)

            : base(info)

         {

         }

         public override Encoding Encoding

         {

            get

            {

               return Encoding.UTF8;

            }

         }

      }

      public string SerializeGPX(gpxType targetInstance)

      {

         string retVal = string.Empty;

         using(StringWriterExt writer = new StringWriterExt(CultureInfo.InvariantCulture))

         {

            XmlSerializer serializer = new XmlSerializer(targetInstance.GetType());

            serializer.Serialize(writer, targetInstance);

            retVal = writer.ToString();

         }

         return retVal;

      }

      public gpxType DeserializeGPX(string objectXml)

      {

         gpxType retVal = null;

         using(StringReader stringReader = new StringReader(objectXml))

         {

            XmlTextReader xmlReader = new XmlTextReader(stringReader);

            XmlSerializer serializer = new XmlSerializer(typeof(gpxType));

            retVal = serializer.Deserialize(xmlReader) as gpxType;

            xmlReader.Close();

         }

         return retVal;

      }

      /// <summary>

      /// exports gps data to gpx file

      /// </summary>

      /// <param name="log">gps data</param>

      /// <param name="gpxFile">file to export</param>

      /// <returns>true if success</returns>

      public bool ExportGPX(IEnumerable<List<GpsLog>> log, string gpxFile)

      {

         try

         {

            gpxType gpx = new gpxType();

            {

               gpx.creator = "GMap.NET - http://greatmaps.codeplex.com";

               gpx.trk = new trkType[1];

               gpx.trk[0] = new trkType();

            }

            var sessions = new List<List<GpsLog>>(log);

            gpx.trk[0].trkseg = new trksegType[sessions.Count];

            int sesid = 0;

            foreach(var session in sessions)

            {

               trksegType seg = new trksegType();

               {

                  seg.trkpt = new wptType[session.Count];

               }

               gpx.trk[0].trkseg[sesid++] = seg;

               for(int i = 0; i < session.Count; i++)

               {

                  var point = session[i];

                  wptType t = new wptType();

                  {

                     #region -- set values --

                     t.lat = new decimal(point.Position.Lat);

                     t.lon = new decimal(point.Position.Lng);

                     t.time = point.TimeUTC;

                     t.timeSpecified = true;

                     if(point.FixType != FixType.Unknown)

                     {

                        t.fix = (point.FixType == FixType.XyD ? fixType.Item2d : fixType.Item3d);

                        t.fixSpecified = true;

                     }

                     if(point.SeaLevelAltitude.HasValue)

                     {

                        t.ele = new decimal(point.SeaLevelAltitude.Value);

                        t.eleSpecified = true;

                     }

                     if(point.EllipsoidAltitude.HasValue)

                     {

                        t.geoidheight = new decimal(point.EllipsoidAltitude.Value);

                        t.geoidheightSpecified = true;

                     }

                     if(point.VerticalDilutionOfPrecision.HasValue)

                     {

                        t.vdopSpecified = true;

                        t.vdop = new decimal(point.VerticalDilutionOfPrecision.Value);

                     }

                     if(point.HorizontalDilutionOfPrecision.HasValue)

                     {

                        t.hdopSpecified = true;

                        t.hdop = new decimal(point.HorizontalDilutionOfPrecision.Value);

                     }

                     if(point.PositionDilutionOfPrecision.HasValue)

                     {

                        t.pdopSpecified = true;

                        t.pdop = new decimal(point.PositionDilutionOfPrecision.Value);

                     }

                     if(point.SatelliteCount.HasValue)

                     {

                        t.sat = point.SatelliteCount.Value.ToString();

                     }

                     #endregion

                  }

                  seg.trkpt[i] = t;

               }

            }

            sessions.Clear();

#if !PocketPC

            File.WriteAllText(gpxFile, SerializeGPX(gpx), Encoding.UTF8);

#else

            using(StreamWriter w = File.CreateText(gpxFile))

            {

               w.Write(SerializeGPX(gpx));

               w.Close();

            }

#endif

         }

         catch(Exception ex)

         {

            Debug.WriteLine("ExportGPX: " + ex.ToString());

            return false;

         }

         return true;

      }

      #endregion

      /// <summary>

      /// gets image from tile server

      /// </summary>

      /// <param name="provider"></param>

      /// <param name="pos"></param>

      /// <param name="zoom"></param>

      /// <returns></returns>

      public PureImage GetImageFrom(GMapProvider provider, GPoint pos, int zoom, out Exception result)

      {

         PureImage ret = null;

         result = null;

         try

         {

            var rtile = new RawTile(provider.DbId, pos, zoom);

            // let't check memmory first

            if(UseMemoryCache)

            {

               var m = MemoryCache.GetTileFromMemoryCache(rtile);

               if(m != null)

               {

                  if(GMapProvider.TileImageProxy != null)

                  {

                     ret = GMapProvider.TileImageProxy.FromArray(m);

                     if(ret == null)

                     {

#if DEBUG

                        Debug.WriteLine("Image disposed in MemoryCache o.O, should never happen ;} " + new RawTile(provider.DbId, pos, zoom));

                        if(Debugger.IsAttached)

                        {

                           Debugger.Break();

                        }

#endif

                        m = null;

                     }

                  }

               }

            }

            if(ret == null)

            {

               if(Mode != AccessMode.ServerOnly && !provider.BypassCache)

               {

                  if(PrimaryCache != null)

                  {

                     // hold writer for 5s

                     if(cacheOnIdleRead)

                     {

                        Interlocked.Exchange(ref readingCache, 5);

                     }

                     ret = PrimaryCache.GetImageFromCache(provider.DbId, pos, zoom);

                     if(ret != null)

                     {

                        if(UseMemoryCache)

                        {

                           MemoryCache.AddTileToMemoryCache(rtile, ret.Data.GetBuffer());

                        }

                        return ret;

                     }

                  }

                  if(SecondaryCache != null)

                  {

                     // hold writer for 5s

                     if(cacheOnIdleRead)

                     {

                        Interlocked.Exchange(ref readingCache, 5);

                     }

                     ret = SecondaryCache.GetImageFromCache(provider.DbId, pos, zoom);

                     if(ret != null)

                     {

                        if(UseMemoryCache)

                        {

                           MemoryCache.AddTileToMemoryCache(rtile, ret.Data.GetBuffer());

                        }

                        EnqueueCacheTask(new CacheQueueItem(rtile, ret.Data.GetBuffer(), CacheUsage.First));

                        return ret;

                     }

                  }

               }

               if(Mode != AccessMode.CacheOnly)

               {

                  ret = provider.GetTileImage(pos, zoom);

                  {

                     // Enqueue Cache

                     if(ret != null)

                     {

                        if(UseMemoryCache)

                        {

                           MemoryCache.AddTileToMemoryCache(rtile, ret.Data.GetBuffer());

                        }

                        if (Mode != AccessMode.ServerOnly && !provider.BypassCache)

                        {

                           EnqueueCacheTask(new CacheQueueItem(rtile, ret.Data.GetBuffer(), CacheUsage.Both));

                        }

                     }

                  }

               }

               else