Organic Maps sources as of 02.04.2025 (fad26bbf22ac3da75e01e62aa01e5c8e11861005)

To expand with full Organic Maps and Maps.ME commits history run:
  git remote add om-historic [om-historic.git repo url]
  git fetch --tags om-historic
  git replace squashed-history historic-commits

data/benchmarks/android/init_device.sh

@@ -0,0 +1,3 @@
+adb shell am force-stop app.organicmaps
+adb push ../config.txt /mnt/sdcard/MapsWithMe/bench/config.txt
+adb push ../settings.ini /mnt/sdcard/MapsWithMe/settings.ini

data/benchmarks/android/show_results.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+adb pull /mnt/sdcard/MapsWithMe/results.txt ../results.txt
+cd ..
+python tk_results_viewer.py config.txt results.txt

data/benchmarks/cmd_results_viewer.py

@@ -0,0 +1,82 @@
+import math
+import sys
+
+
+f1 = open(sys.argv[2], "r")
+lns1 = f1.readlines()
+lns1 = [l.split(" ") for l in lns1]
+
+bench_cfg = {}
+
+for l in lns1:
+    c_name = l[1]
+    is_country = (len(l) == 3)
+    bench_cfg[l[1]] = []
+    bench_cfg[l[1]].append(is_country) 
+    if len(l) > 0:
+        if not is_country:
+            bench_cfg[c_name].append(float(l[2]))
+            bench_cfg[c_name].append(float(l[3]))
+            bench_cfg[c_name].append(float(l[4]))
+            bench_cfg[c_name].append(float(l[5]))
+            bench_cfg[c_name].append(int(l[6]))
+        else:
+            bench_cfg[c_name].append(int(l[2]))
+
+f = open(sys.argv[1], "r")
+lns = f.readlines()
+
+def scale_level(r):
+    dx = 360.0 / (r[2] - r[0])
+    dy = 360.0 / (r[3] - r[1])
+
+    v = (dx + dy) / 2.0
+
+    l = math.log(v) / math.log(2.0) + 1
+    if l > 17:
+        l = 17
+    if l < 0:
+        return 0
+    else:
+        return math.floor(l + 0.5)
+
+lns = [l.split(" ") for l in lns]
+
+rev = {}
+
+for l in lns:
+    rev_name = l[1]
+    start_time = l[2]
+    bench_name = l[3]
+
+    rect = [float(l[4]), float(l[5]), float(l[6]), float(l[7])]
+    dur = float(l[8])
+    if not rev.has_key(rev_name):
+        rev[rev_name] = {}
+    if not rev[rev_name].has_key(start_time):
+        rev[rev_name][start_time] = {}
+    if not rev[rev_name][start_time].has_key(bench_name):
+        rev[rev_name][start_time][bench_name] = {}
+
+    scale = scale_level(rect)
+
+    if not rev[rev_name][start_time][bench_name].has_key(scale):
+        rev[rev_name][start_time][bench_name][scale] = 0
+
+    rev[rev_name][start_time][bench_name][scale] += dur
+
+for rev_name in rev.keys():
+    print rev_name
+    for start_time in rev[rev_name].keys():
+        print "\t", start_time
+        for bench_name in rev[rev_name][start_time].keys():
+
+            cfg_info = bench_cfg[bench_name]
+            if not cfg_info[0]:
+                print "\t\t", bench_name, "[", cfg_info[1], cfg_info[2], cfg_info[3], cfg_info[4], "]", "endScale=", cfg_info[5]
+            else:
+                print "\t\t", bench_name, "endScale=", cfg_info[1]
+            k = rev[rev_name][start_time][bench_name].keys()
+            k.sort()
+            for scale_level in k:
+                print "\t\t\t scale: ", scale_level, ", duration: " , rev[rev_name][start_time][bench_name][scale_level]

data/benchmarks/config.txt

@@ -0,0 +1 @@
+Netherlands.mwm Amsterdam-Center 52.3400 4.8089 52.4091 4.9948 17

data/benchmarks/settings.ini

@@ -0,0 +1,6 @@
+IsBenchmarking=true
+BenchmarkConfig=bench/config.txt
+BenchmarkResults=bench/results.txt
+ShouldShowFacebookDialog=false
+ShouldShowBuyProDialog=false
+ShouldShowAppStoreRate=false

data/benchmarks/tk_results_viewer.py

@@ -0,0 +1,253 @@
+from Tkinter import *
+import tkMessageBox
+import math
+import sys
+import copy
+import os
+import shutil
+import time
+
+def less_start_time(t1, t2):
+    fmt = '%a_%b_%d_%H:%M:%S_%Y'
+    return time.strptime(t1[0].replace('__','_'), fmt) < time.strptime(t2[0].replace('__','_'), fmt)
+
+class BenchmarkResultsFrame(Frame):
+    def __init__(self, cfg_file, results_file, master=None):
+        Frame.__init__(self, master)
+
+        self.master.title("Benchmark Results Viewer")
+        self.grid(padx=10, pady=10)
+
+        self.createWidgets()
+        self.resultsDir = os.path.dirname(results_file)
+        self.readResults(cfg_file, results_file)
+        self.current = None
+        self.poll()
+
+    def scale_level(self, r):
+        dx = 360.0 / (r[2] - r[0])
+        dy = 360.0 / (r[3] - r[1])
+
+        v = (dx + dy) / 2.0
+
+        l = math.log(v) / math.log(2.0) + 1
+        return math.floor(max(0, min(l, 17)) + 0.5)
+
+    def poll(self):
+        now = self.resultsList.curselection()
+        if now != self.current:
+            self.onResultsChanged(now)
+            self.current = now
+        self.after(100, self.poll)
+
+    def onResultsChanged(self, now):
+        if len(now) == 0:
+            return
+
+        self.resultsView.delete(1.0, END)
+
+        for i in now:
+            start_time = self.resultsList.get(int(i))
+
+            for rev_name in self.rev.keys():
+                if start_time in self.rev[rev_name]:
+                    self.resultsView.insert(END, rev_name + "\n")
+                    self.resultsView.insert(END, "\t%s\n" % (start_time))
+                    for bench_name in self.rev[rev_name][start_time].keys():
+                        if bench_name not in self.bench_cfg:
+                            s = "\t\t%s [config info not found]\n" % (bench_name)
+                            self.resultsView.insert(END, s)
+                        else:
+                            cfg_info = self.bench_cfg[bench_name]
+                            if not cfg_info[0]:
+                                s = "\t\t%s [%s %s %s %s], endScale=%d\n" % \
+                                    (bench_name, cfg_info[1], cfg_info[2], cfg_info[3], cfg_info[4], cfg_info[5])
+                                self.resultsView.insert(END, s)
+                            else:
+                                s = "\t\t%s endScale=%d\n" % \
+                                    (bench_name, cfg_info[1])
+                                self.resultsView.insert(END, s)
+                        k = self.rev[rev_name][start_time][bench_name].keys()
+                        k.sort()
+                        for scale_level in k:
+                            s = "\t\t\t scale: %d, duration: %f\n" % \
+                                (scale_level, self.rev[rev_name][start_time][bench_name][scale_level])
+                            self.resultsView.insert(END, s)
+
+            self.resultsView.insert(END, "-------------------------------------------------------------------\n")
+            if self.hasTraceAttachement(start_time):
+                self.resultsView.insert(END, "%s attached\n" % (self.traceAttachementFile(start_time)))
+
+    def readResults(self, cfg_file, results_file):
+        self.results_file = results_file
+
+        f1 = open(cfg_file, "r")
+        lns1 = f1.readlines()
+        lns1 = [l.split(" ") for l in lns1]
+
+        # reading benchmark configuration info
+
+        self.bench_cfg = {}
+
+        for l in lns1:
+            c_name = l[1]
+            is_country = (len(l) == 3)
+            self.bench_cfg[l[1]] = []
+            self.bench_cfg[l[1]].append(is_country)
+            if len(l) > 0:
+                if not is_country:
+                    self.bench_cfg[c_name].append(float(l[2]))
+                    self.bench_cfg[c_name].append(float(l[3]))
+                    self.bench_cfg[c_name].append(float(l[4]))
+                    self.bench_cfg[c_name].append(float(l[5]))
+                    self.bench_cfg[c_name].append(int(l[6]))
+                else:
+                    self.bench_cfg[c_name].append(int(l[2]))
+
+        # reading results file
+
+        f = open(results_file, "r")
+        lns = f.readlines()
+
+        lns = [l.strip().split(" ") for l in lns]
+
+        self.rev = {}
+
+        cur_start_time = None
+        is_session = False
+
+        self.start_time_list = []
+        self.completion_status = []
+
+        for l in lns:
+            if l[0] == "START":
+                if cur_start_time is not None:
+                    if is_session:
+                        # unfinished benchmark, mark as incomplete
+                        self.completion_status.append(0)
+                    else:
+                        # unknown status
+                        self.completion_status.append(2)
+                cur_start_time = l[1].strip("\n")
+                self.start_time_list.append(cur_start_time)
+                is_session = True
+                continue
+
+            if l[0] == "END":
+                if not is_session:
+                    raise "END without matching START"
+                self.completion_status.append(1)
+                cur_start_time = None
+                is_session = False
+                continue
+
+            if len(l) < 9:
+                "android benchmarks don't write first item"
+                l = [" "] + l
+            rev_name = l[1]
+            start_time = l[2]
+            bench_name = l[3]
+
+            if cur_start_time != start_time:
+                # checking whether new start_time breaks current session
+                if is_session:
+                    self.completion_status.append(0)
+                    is_session = False
+                else:
+                    if cur_start_time is not None:
+                        # unknown session type
+                        self.completion_status.append(2)
+
+                cur_start_time = start_time
+                self.start_time_list.append(cur_start_time)
+
+            rect = [float(l[4]), float(l[5]), float(l[6]), float(l[7])]
+            dur = float(l[8])
+            if rev_name not in self.rev:
+                self.rev[rev_name] = {}
+            if start_time not in self.rev[rev_name]:
+                self.rev[rev_name][start_time] = {}
+            if bench_name not in self.rev[rev_name][start_time]:
+                self.rev[rev_name][start_time][bench_name] = {}
+
+            scale = self.scale_level(rect)
+
+            if scale not in self.rev[rev_name][start_time][bench_name]:
+                self.rev[rev_name][start_time][bench_name][scale] = 0
+
+            self.rev[rev_name][start_time][bench_name][scale] += dur
+
+        if cur_start_time is not None:
+            if is_session:
+                self.completion_status.append(0)
+            else:
+                self.completion_status.append(2)
+
+        # sorting session list. latest results go first.
+
+        if len(self.start_time_list) != len(self.completion_status):
+            raise "something wrong with file parsing, list sizes don't match"
+
+        self.start_time_pairs = [(self.start_time_list[i], self.completion_status[i]) for i in range(0, len(self.start_time_list))]
+
+        self.start_time_pairs.sort(less_start_time)
+
+        # updating resultList with names and completion status
+
+        i = 0
+
+        for e in self.start_time_pairs:
+            self.resultsList.insert(END, e[0])
+            if e[1] == 0:
+                self.resultsList.itemconfig(i, fg="red")
+            elif e[1] == 1:
+                self.resultsList.itemconfig(i, fg="blue")
+            elif e[1] == 2:
+                self.resultsList.itemconfig(i, fg="green")
+            i += 1
+
+    def hasTraceAttachement(self, start_time):
+        return self.traceAttachementFile(start_time) is not None
+
+    def traceAttachementName(self, start_time):
+        return start_time.strip("\n").replace("_", "").replace(":", "").replace("-", "")
+
+    def traceAttachementFile(self, start_time):
+        trace_files = [t for t in os.listdir(os.path.join(os.curdir, self.resultsDir)) if t.endswith(".trace")]
+        sst = self.traceAttachementName(start_time)
+        for tf in trace_files:
+            stf = tf[0:-6].replace("_", "").replace(":", "").replace("-", "")
+            if stf == sst:
+                return tf
+
+    def deleteTraceAttachement(self, start_time):
+        sst = self.traceAttachementName(start_time)
+        if tkMessageBox.askokcancel("Profiler results found", "Delete " + self.traceAttachementFile(start_time)):
+            shutil.rmtree(self.traceAttachementFile(start_time))
+
+    def removeRecord(self, event):
+        idx = self.resultsList.nearest(event.y)
+        start_time = self.resultsList.get(idx)
+
+        if tkMessageBox.askokcancel("Are you sure?", "Delete results for " + start_time + " session?"):
+            lns = open(self.results_file, "r").readlines()
+            lns = [l for l in lns if l.find(start_time) == -1]
+            open(self.results_file, "w").writelines(lns)
+            self.resultsList.delete(idx)
+
+            if self.hasTraceAttachement(start_time):
+                self.deleteTraceAttachement(start_time)
+
+    def createWidgets(self):
+        self.resultsList = Listbox(self, width=30, height=60, selectmode=EXTENDED)
+        self.resultsList.grid(row=0, column=0)
+        self.resultsList.bind("<Double-Button-1>", self.removeRecord)
+
+        self.resultsView = Text(self, width=80, height=60)
+        self.resultsView.grid(row=0, column=1, columnspan=3)
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print "usage: python %s [config.info] [results.txt]" % sys.argv[0]
+    root = BenchmarkResultsFrame(sys.argv[1], sys.argv[2])
+    root.mainloop()

data/benchmarks/update_benchmark.sh

@@ -0,0 +1,25 @@
+echo "start update benchmark system"
+echo "get result from device"
+filedate=`date +%d-%m-%y`
+filepath=~/Dropbox/results/$filedate
+filepath+="_result.txt"
+adb pull /mnt/sdcard/MapsWithMe/bench/results.txt $filepath
+cd ~/dev/omim/
+echo "current work dir : " $PWD
+git checkout master
+echo "pull upstream"
+git fetch upstream
+git merge upstream/master
+echo "move to android dir"
+cd android/MapsWithMePro/
+echo "current work dir : " $PWD
+echo "rebuild application"
+ant clean
+ant release
+echo "uninstall application from device"
+adb uninstall app.organicmaps
+echo "install new build"
+adb install bin/MapsWithMePro-release.apk
+echo "start application"
+adb shell am start -n app.organicmaps/app.organicmaps.DownloadResourcesActivity
+