Cześć,

Mam problem ze skryptem. Chcę "przerzucić" dane wektorowe + bazę sqlite do jednej aplikacji, zainstalowanej na urządzeniu mobilnym.
Podczas uruchamiania skryptu, pliki w katalogu na komputerze kopiują się, natomiast na urządzenie już niestety nie. Pojawia się komunikat: 'Nie można odnaleźć określonego pliku'.
W wierszu poleceń, faktycznie nie mogę się dostać do konkretnych ścieżek w urządzeniu. Ps. Python jest dla mnie nowością ;).

# -*- coding: utf-8 -*-

import subprocess
import shutil
import os
import datetime
import time
import sqlite3

# Tworzenie kopii calego projektu w katalogu wymiany (patrz katalog wymiany)
backupProjectPc = 0

# kopiuj na urzadzenie [meta_db, vector_db, raster_db]
copyToDevice = [1, 1, 0]     # [1,1,0] [0,0,0] [1,0, 0]

# kopiuj na komputer [meta_db, vector_db]
copyToPc = [0, 0]        # [1,1] [0,0] [1,0]
# aktualizuj nazwy styli na podstawie katalogu pliko sld (po skopiowaniu)
updateStyle = 0

# kopiuj pliki z katalogu na komputerze do katalogu na urzadzeniu
copyDirToDevice = 0
srcDirPc = r'C:/Dane/(pełna ściażka do katalogu w komputerze)'
trgDir = r'/storage/emulated/0/Download' #ścieżka do tabletu, podpiętego poprzez USB (debugowanie włączone)

# katalog wymiany pomiedzy komputerem a urzadzeniem z Androidem

exchangeDir = r'C:/Dane/(pełna ścieżka)/katalog wymiany'
editDir = r'C:/Dane/pełna ścieżka'  # # katalog z edytowana baza na komputerze stacjonarnym 
projectsDir = r'/storage/emulated/0/Android/data/(katalog projektu)/files/projects/main' # mlas Pro 6.1
projectName = r''      # nazwa projektu, w ktorym bedzie podmieniana metabaza i ktory bedzie kopiowany na komputer

# nazwy baz zwiazanych z projektem
metaDbName = r'meta_db.sqlite'                              # nazwa metabazy
vectorDbName = r'vectors.sqlite'                            # nazwa bazy wektorowej
rasterDbName = r'rasters.sqlite'                            # nazwa bazy rastrowej
crsFileName = r'prj'                                        # nazwa pliku z ukladem projektu
copySuffix = "_Copy"                                        # suffix dodawany do kopii plikow

# lista nazw plikow wymienionych powyzej, ktore sa skladowymi projektu i maja byc z nim backupowane
projectFilesList = [metaDbName, vectorDbName, rasterDbName, crsFileName]

# Sciezka do adb.exe (potrzebne jest popranie Android SDK)
adbPath = r'C:/Users/(ścieżka do adb)/adb.exe'
adbPath = os.path.join(os.getcwd(), 'adb\\adb.exe')

# zmienne potrzebne do aktualizacji nazwy stylu
styleDir = r'd:/meta/style'                         # katalog do zapisu styli dla warstw (taki, do ktorego byl robiony unload)
defaultStyleDir = r'd:\meta\default_style'          # katalog do zapisu styli domyslnycch (taki, do ktorego byl robiony unload)
defaultTab = r'default_style'                       # nazwa tabeli ze stylami domyslnymi
defaultTabFields = ['id', 'name', 'sld_xml']        # lista pol (pole z nazwa oraz  pole z xml stylu)
styleTab = r'style'                                 # nazwa tabeli ze stylami dla warstw
styleTabFields = ['id', 'name', 'sld_xml']           # lista pol (pole z nazwa oraz  pole z xml stylu)

def forceStopApp():
    """Funkcja wymuszajaca zatrzymanie aplikacji na urzadzeniu """
    print(adbPath)
    p = subprocess.Popen([adbPath, 'shell', 'am', 'force-stop', packageName], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = p.communicate()
    if "failed" in stderr or "error" in stderr:
        print("Blad zamykania aplikacji na urzadzeniu " + stderr)
    else:
        print("Aplikacja zamknieta " + stderr)
    #    p.kill()

def startApp():
    """Funkcja uruchamiajaca ponownie aplikacje.
        W celu prawidlowego dzialania funkcji nalezy poprawnie zdefiniowac zmienne globalne:
        - nazwa pakietu (packageName)
        - nazwa startowego activity aplikacji (startActivity) """
    p = subprocess.Popen([adbPath, 'shell', 'am', 'start', packageName + "/." + startActivity], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = p.communicate()
    if "failed" in stderr or "error" in stderr:
        print("Blad uruchomienia aplikacji na urzadzeniu " + stderr)
    else:
        print("Aplikacja uruchomiona " + stderr)
    #    p.kill()

def setPathSep(path):
    """zmiana sciezku tak by byla poprawnie interpretowana przez adb """
    newPath = path.replace("\\", '/')
    return newPath

def copyFile(fileToCopy, trgDir):
    """Funkcja kopiujaca plik (fileToCopy) do katalogu (trgDir)"""
    shutil.copy(fileToCopy, trgDir)
    print("Skopiowano plik %s do katalogu %s" % (os.path.basename(fileToCopy), trgDir))

def pushFile(pushFile, trgDir):
    """Funkcja kopiujaca plik (pushFile) do katalogu na urzadzeniu (trgDir) """
    p = subprocess.Popen([adbPath, r'push', pushFile, trgDir], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = p.communicate()
    print(trgDir)
    if "failed" in stderr or "error" in stderr:
        print("Blad kopiowania pliku %s na urzadzenie " % os.path.basename(pushFile) + stderr)
    else:
        print("Skopiowano plik %s na urzadzenie " % os.path.basename(pushFile) + stderr)
    #    p.kill()

def pullFile(pullFile, trgFile):
    """Funkcja kopujaca plik (pullFile) jako plik (trgFile) na komputer"""
    p = subprocess.Popen([adbPath, r'pull', pullFile, trgFile], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = p.communicate()
    if "does not" in stderr or "failed" in stderr or "error" in stderr:
        print("Blad kopiowania pliku %s z urzadzenia na komputer " % os.path.basename(pullFile) + stderr)
    else:
        print("Skopiowano plik %s z urzadzenia.\nLokalizacja kopii na komputerze: %s " % (os.path.basename(pullFile), trgFile) + stderr)
    #    p.kill()

def deleteFile(pathToFile):
    """Funkcja usuwająca wskazany plik z urzadzenia """

    p = subprocess.Popen([adbPath, 'shell',  r'rm', pathToFile], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = p.communicate()
    if "does not"  in stderr or "failed" in stderr or "error" in stderr:
        print("Blad usuwania pliku %s na urzadzeniu " % os.path.basename(pathToFile) + stderr)
    else:
        print("Usunieto plik %s na urzadzeniu " % (os.path.basename(pathToFile)) + stderr)
    #    p.kill()

def makeBackupDir(projectName, trgDir):
    """Funkcja zakladajaca katalog projektu (projectName) do przwchowania backup-u w zadanej lokalizacji na komputerze (trgDir)"""
    ts = time.time()
    st =  projectName + " " + datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S').replace(":", "_")
    backupDir = os.path.join(trgDir, st)
    os.mkdir(backupDir)
    return backupDir

def backupProject(projectFilesList):
    """Funkcja tworzaca backup wszystkich plikow skladowych (projectFilesList) w nowym folderze na komputerze"""
    # przygotuj katalog na backup
    backupDir = makeBackupDir(projectName,exchangeDir)
    for projectFile in projectFilesList:
        pullFile(appFilePath(projectFile), backupDir)

    print("Utworzono backup projektu w katalogu %s" % backupDir)

def appFilePath(fileName):
    """Funkcja skladajaca pelna sciezke do metabazy"""
    appFilePath = setPathSep(os.path.join(os.path.join(projectsDir, projectName), fileName))
    return appFilePath

def pcFilePath(trgDir, fileName):
    """Funkcja skladaja pelna sciezke pliku na kompueterze"""
    pcFilePath = os.path.join(trgDir, fileName)
    return pcFilePath

def copyFileName(fileName, suffix):
    """Funkcja skladaja nazwe kopii """
    copyFileName = fileName.split('.')[0] + suffix + '.' + fileName.split('.')[1]
    return copyFileName

def updateStyleName(styleDir, trgFile, tabName, tabFields):
    """Funkcja aktualizujaca w kopii metabazy (copyFile) nazwe stylow z katalogu (styleDir) na podstawie wczesniej wyeksportowanych plikow"""

    styleFilesList = [f for f in os.listdir(styleDir) if os.path.isfile(os.path.join(styleDir, f))]

    # polaczenie z baza danych
    conn = sqlite3.connect(trgFile)
    c = conn.cursor()

    for styleFileName in styleFilesList:
        styleName = styleFileName.split('.')[0][(styleFileName.split('.')[0].find('_'))+1:]
        styleId = int((styleFileName.split('.')[0]).split('_')[0])

        if tabName == 'style':
            c.execute( ''' UPDATE style SET name = ? WHERE id = ? ''', (styleName, styleId))
            conn.commit()
            print("Aktulizacja stylu %s " %styleName)

        if tabName == 'default_style':
            c.execute( ''' UPDATE default_style SET name = ? WHERE id = ? ''', (styleName, styleId))
            conn.commit()
            print("Aktulizacja stylu %s " %styleName)

    conn.close()
        #print styleName + str(styleId)

def copyFilesToDevice(srcDir, trgDir):
    """Funkcja kopiujaca pliki z danego katalog na komputerze do katalogu na urzadzeniu """
    # lista plikow
    filesList = [f for f in os.listdir(srcDir) if os.path.isfile(os.path.join(srcDir, f))]
    for f in filesList:
        pushFile(os.path.join(srcDir, f), trgDir)

def listFilesAdb(srcDir):
    """ Funkcja listujaca pliki w katalogu na urzadzeniu (srcDir) """
    p = subprocess.Popen([adbPath, r'shell', 'ls', '-R' , srcDir,], stdout= subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = p.communicate()
    if "does not"  in stderr or "failed" in stderr or "error" in stderr:
        print("Listowania plikow w katalogu %s  na urzadzeniu " % os.path.basename(srcDir) + stderr)
    else:
        return(stdout)
#    p.kill()

# ZASADNICZY PROGRAM

if backupProjectPc == 1:
    # utworz kopie projektu
    backupProject(projectFilesList)

if copyToDevice[0] == 1 or copyToDevice[1] == 1:

    # zamkniecie aplikacji
    #forceStopApp()

    if copyToDevice[0] == 1:

        # kopiowanie metabazy do katalogu wymiany
        copyFile(os.path.join(editDir, metaDbName), exchangeDir)
        # kopiowanie metabazy na urzadzenie
        pushFile(os.path.join(exchangeDir, metaDbName), setPathSep(os.path.join(projectsDir, projectName)))

        # usuwanie cache
        if projectName != '':
            vectorCache = setPathSep(os.path.join(os.path.join(projectsDir, projectName), "cache_vector"))
        else:
            vectorCache = setPathSep(os.path.join(projectsDir, "cache.vector"))
        deleteFile(vectorCache)

    if copyToDevice[1] == 1:
        # kopiowanie bazy wektorowej do katalogu wymiany
        copyFile(os.path.join(editDir, vectorDbName), exchangeDir)
        # kopiowanie bazy wektorowej na urzadzenie
        pushFile(os.path.join(exchangeDir, vectorDbName), setPathSep(os.path.join(projectsDir, projectName)))

    if copyToDevice[2] == 1:
         # kopiowanie bazy rastrowej do katalogu wymiany
        copyFile(os.path.join(editDir, rasterDbName), exchangeDir)
        # kopiowanie bazy rastrowej
        pushFile(os.path.join(exchangeDir, rasterDbName), setPathSep(os.path.join(projectsDir, projectName)))

    # uruchomienie aplikacji
    startApp()

if copyToPc[0] == 1:
    # kopiowanie metabazy z urzadzenia na komputer
    pullFile(appFilePath(metaDbName), pcFilePath(exchangeDir, copyFileName(metaDbName, copySuffix)))
    if updateStyle == 1:
        updateStyleName(styleDir, pcFilePath(exchangeDir, copyFileName(metaDbName, copySuffix)), styleTab, styleTabFields)

if copyToPc[1] == 1:
    # kopiowanie bazy wektorowej z urzadzenia na komputer
    pullFile(appFilePath(vectorDbName), pcFilePath(exchangeDir, copyFileName(vectorDbName, copySuffix)))

if copyDirToDevice == 1:
    copyFilesToDevice(srcDirPc, trgDir)

if copyDirFromDevice == 1:
    content = listFilesAdb(srcDir)
    lis = content.split('\n')
    for pos in lis:
        if '.' in pos and ':' not in pos:
            fileToPull = srcDir + '/' + pos.strip('\r')
            pullFile(fileToPull, os.path.join(exchangeDir, pos.strip('\r')))