private static void PhoneUploadNvItem(QcdmManager manager, string path, ushort nvItemId, Logger logger)
{
try
{
var filePath = PathUtils.GetNvItemFileName(nvItemId);
filePath = Path.Combine(path, filePath);
if (File.Exists(filePath))
{
using (var input = FileUtils.LocalOpenRead(filePath))
{
using (var output = NvOpenWrite(manager, nvItemId))
{
StreamUtils.Copy(input, output);
output.Flush();
output.Close();
}
input.Close();
}
}
}
catch
{
}
}
public QcdmManagerNvWriteStreamAdapter(QcdmManager manager, ushort id)
{
_manager = manager;
_stream = new MemoryStream();
_id = id;
_closed = false;
}
public EfsStore(QcdmManager manager, bool readOnly, Logger logger, LogLevel logLevel)
{
_manager = manager;
_readOnly = readOnly;
_logger = logger;
_logLevel = logLevel;
}
private static void PhoneUploadFile(QcdmManager manager, string computerPath, string efsPath,
bool createItemFilesAsDefault, int subscription, Logger logger)
{
try
{
var fileName = Path.GetFileName(computerPath);
if (fileName != null)
{
var isItemFile = createItemFilesAsDefault;
var permission = 0x81FF;
var info = PathUtils.ParsePath(fileName);
if (info != null)
{
permission = info.Permission;
isItemFile = info.IsItemFile;
}
// Fail-safe in case we're trying to write a large item file
if (isItemFile)
{
var size = GetFileSize(computerPath);
if (size > 2048)
{
isItemFile = false;
}
}
PhoneWriteFile(manager, computerPath, efsPath, permission, isItemFile, subscription, logger);
}
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnUploadFormat, efsPath, e.Message));
}
}
public static void PhoneUploadDirectory(QcdmManager manager, string computerPath, string efsPath,
bool createItemFilesAsDefault, Logger logger)
{
try
{
logger.LogInfo(string.Format(Strings.QcdmProcessingFormat, computerPath));
var directories = Directory.EnumerateDirectories(computerPath);
var files = Directory.EnumerateFiles(computerPath);
PhoneCreateDirectory(manager, efsPath, true, logger);
foreach (var directory in directories)
{
var name = Path.GetFileName(directory);
var path = $"{efsPath}{name}/";
PhoneUploadDirectory(manager, directory, path, createItemFilesAsDefault, logger);
}
foreach (var file in files)
{
if (file != null && !PathUtils.IsNvItemFileName(file))
{
var fileName = Path.GetFileName(file);
var path = PathUtils.RemoveExtraData(fileName, efsPath);
PhoneUploadFile(manager, file, path, createItemFilesAsDefault, logger);
}
}
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnUploadDirectoryFormat, efsPath, e.Message));
}
}
public static void PhoneDownloadDirectory(QcdmManager manager, string efsPath, string computerPath,
bool noExtraData, Logger logger)
{
try
{
var entries = PhoneOpenDirectory(manager, efsPath, logger);
if (entries != null)
{
Directory.CreateDirectory(computerPath);
foreach (var entry in entries)
{
if (entry.EntryType == DirectoryEntryType.Directory)
{
var path = $"{efsPath}{entry.Name}/";
var newComputerPath = $"{computerPath}{entry.Name}/";
PhoneDownloadDirectory(manager, path, newComputerPath, noExtraData, logger);
continue;
}
if (entry.EntryType == DirectoryEntryType.File ||
entry.EntryType == DirectoryEntryType.ItemFile)
{
PhoneDownloadFile(manager, entry, efsPath, computerPath, noExtraData, logger);
}
}
}
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnDownloadDirectoryFormat, efsPath, e.Message));
}
}
public static void PhoneFixFileNames(QcdmManager manager, string path, Logger logger)
{
try
{
if (!string.IsNullOrEmpty(path))
{
var entries = PhoneOpenDirectory(manager, path, logger);
if (entries != null)
{
foreach (var entry in entries)
{
if (entry.EntryType == DirectoryEntryType.Directory)
{
var path1 = $"{path}{entry.Name}/";
PhoneFixFileNames(manager, path1, logger);
continue;
}
if (entry.EntryType == DirectoryEntryType.File ||
entry.EntryType == DirectoryEntryType.ItemFile)
{
PhoneCheckAndFixFileName(manager, entry.Name, path, logger);
}
}
}
}
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnFixFileNamesFormat, path, e.Message));
}
}
public static Dictionary <string, object> PhoneLoadItems(QcdmManager manager, int subscription)
{
var items = new Dictionary <string, object>();
foreach (var filePath in ItemsFactory.SupportedEfsFilePaths)
{
var realFilePath = GetEfsFilePath(filePath, subscription);
if (manager.Efs.FileExists(realFilePath))
{
var itemType = ItemsFactory.GetEfsFileType(filePath);
using (var stream = FileUtils.PhoneOpenRead(manager, realFilePath))
{
var item = ItemsBinarySerializer.Deserialize(stream, itemType);
items.Add(itemType.Name, item);
stream.Close();
}
}
}
foreach (var nvItemId in ItemsFactory.SupportedNvItemIds)
{
var itemType = ItemsFactory.GetNvItemType(nvItemId);
using (var stream = NvOpenRead(manager, (ushort)nvItemId))
{
if (stream != null)
{
var item = ItemsBinarySerializer.Deserialize(stream, itemType);
items.Add(itemType.Name, item);
stream.Close();
}
}
}
return(items);
}
public static void PhoneCreateDirectory(QcdmManager manager, string path, bool recursive, Logger logger)
{
if (!string.IsNullOrEmpty(path) && path != "/")
{
var p = path;
if (p[p.Length - 1] == '/')
{
p = p.Substring(0, p.Length - 1);
}
if (recursive)
{
var ind = p.LastIndexOf('/');
if (ind > 0)
{
var parentPath = p.Substring(0, ind);
if (!string.IsNullOrEmpty(parentPath) && parentPath != "/")
{
PhoneCreateDirectory(manager, parentPath, true, logger);
}
}
PhoneCreateDirectory(manager, p, logger);
}
else
{
PhoneCreateDirectory(manager, p, logger);
}
}
}
private static void PhoneCheckAndFixFileName(QcdmManager manager, string entryName, string efsPath,
Logger logger)
{
var newEntryName = entryName.Replace("\n", "");
newEntryName = newEntryName.Replace("\r", "");
var efs = manager.Efs;
if (newEntryName != entryName)
{
var oldPath = $"{efsPath}{entryName}";
var newPath = $"{efsPath}{newEntryName}";
if (efs.FileExists(newPath))
{
efs.DeleteFile(oldPath);
efs.SyncNoWait(newPath, 1);
}
else
{
efs.RenameFile(oldPath, newPath);
efs.SyncNoWait(newPath, 1);
}
//var stat1 = manager.Efs.FileStat(newPath);
//var stat2 = manager.Efs.FileStat(oldPath);
logger.LogInfo(string.Format(Strings.QcdmFixFileNameFormat, entryName, newEntryName, efsPath));
}
}
private static void PhoneUploadFile(QcdmManager manager, string computerPath, string efsPath,
bool createItemFilesAsDefault, Logger logger)
{
try
{
var fileName = Path.GetFileName(computerPath);
if (fileName != null)
{
var isItemFile = false;
var permission = 0777;
var info = PathUtils.ParsePath(fileName);
if (info == null)
{
isItemFile = createItemFilesAsDefault;
}
else
{
permission = info.Permission;
isItemFile = info.IsItemFile;
}
PhoneWriteFile(manager, computerPath, efsPath, permission, isItemFile, logger);
}
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnUploadFormat, efsPath, e.Message));
}
}
private static void PhoneDownloadNvItem(QcdmManager manager, string path, ushort nvItemId, Logger logger)
{
var filePath = string.Empty;
try
{
filePath = PathUtils.GetNvItemFileName(nvItemId);
filePath = Path.Combine(path, filePath);
using (var input = NvOpenRead(manager, nvItemId))
{
if (input != null)
{
using (var output = FileUtils.LocalCreateWrite(filePath))
{
StreamUtils.Copy(input, output);
output.Flush();
output.Close();
}
input.Close();
}
}
}
catch
{
if (!string.IsNullOrEmpty(filePath) && File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public QcdmManagerItemWriteStreamAdapter(QcdmManager manager, string path, int permission)
{
_manager = manager;
_stream = new MemoryStream();
_path = path;
_permission = permission;
_closed = false;
}
public static EfsStoreItem Create(QcdmManager manager, string name, string uniqueKey, string path,
bool isReadOnly, Logger logger, LogLevel logLevel)
{
var item = new EfsStoreItem(manager, name, uniqueKey, path, isReadOnly, logger, logLevel);
item.Initialize();
return(item);
}
public static void PhoneUploadNvItems(QcdmManager manager, string path, Logger logger)
{
logger.LogInfo(string.Format(Strings.QcdmUploadingNvItems));
for (ushort nvItemId = 1; nvItemId < ushort.MaxValue; ++nvItemId)
{
PhoneUploadNvItem(manager, path, nvItemId, logger);
}
}
public QcdmEfsFileStream(QcdmManager manager, string fileName, EfsFileFlag flags, int permission)
{
_file = -1;
_fileName = fileName;
_flags = flags;
_permission = permission;
_manager = manager;
_position = 0;
}
public static void PhoneSaveItems(QcdmManager manager, Dictionary <string, object> items, Logger logger)
{
var efs = manager.Efs;
foreach (var item in items)
{
var type = item.Value.GetType();
var fileAttribute = EfsFileAttributeUtils.Get(type);
if (fileAttribute == null)
{
var nvItemIdAttribute = NvItemIdAttributeUtils.Get(type);
if (nvItemIdAttribute != null && nvItemIdAttribute.Id <= UInt16.MaxValue)
{
using (var stream = NvOpenWrite(manager, (ushort)nvItemIdAttribute.Id))
{
ItemsBinarySerializer.Serialize(item.Value, stream);
stream.Flush();
stream.Close();
}
}
}
else
{
var path = fileAttribute.Path;
var subscriptionPath = PathUtils.GetSubscriptionPath(path, 1);
if (efs.FileExists(subscriptionPath))
{
efs.DeleteFile(subscriptionPath);
}
else
{
subscriptionPath = string.Empty;
}
using (var stream = fileAttribute.IsItemFile
? FileUtils.PhoneItemCreateWrite(manager, path, fileAttribute.Permissions, logger)
: FileUtils.PhoneCreateWrite(manager, path, fileAttribute.Permissions, logger))
{
ItemsBinarySerializer.Serialize(item.Value, stream);
stream.Flush();
stream.Close();
}
if (!string.IsNullOrEmpty(subscriptionPath))
{
using (var stream = fileAttribute.IsItemFile
? FileUtils.PhoneItemCreateWrite(manager, subscriptionPath, fileAttribute.Permissions,
logger)
: FileUtils.PhoneCreateWrite(manager, subscriptionPath, fileAttribute.Permissions, logger))
{
ItemsBinarySerializer.Serialize(item.Value, stream);
stream.Flush();
stream.Close();
}
}
}
}
}
public static void PhoneDeleteFile(QcdmManager manager, string path, Logger logger)
{
try
{
manager.Efs.DeleteFile(path);
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnDeleteFileFormat, path, e.Message));
}
}
private static Stream NvOpenWrite(QcdmManager manager, ushort nvItemId)
{
try
{
return(new QcdmManagerNvWriteStreamAdapter(manager, nvItemId));
}
catch
{
return(null);
}
}
private static void PhoneCreateDirectory(QcdmManager manager, string efsPath, Logger logger)
{
try
{
manager.Efs.CreateDirectory(efsPath, 0777);
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnCreateDirectoryFormat, efsPath, e.Message));
}
}
public static void PhoneListDirectory(QcdmManager manager, string path, bool recursive, string offset,
Logger logger)
{
try
{
if (!string.IsNullOrEmpty(path))
{
var p = path;
if (p[p.Length - 1] == '/')
{
p = p.Substring(0, p.Length - 1);
}
var entries = PhoneOpenDirectoryForList(manager, p, logger);
if (entries != null)
{
foreach (var entry in entries)
{
if (entry.EntryType == DirectoryEntryType.Directory)
{
logger.LogInfo($"{offset}[{entry.Name}]");
if (recursive)
{
var of = $"{offset} ";
var dirPath = $"{p}/{entry.Name}";
PhoneListDirectory(manager, dirPath, true, of, logger);
}
continue;
}
if (entry.EntryType == DirectoryEntryType.File ||
entry.EntryType == DirectoryEntryType.ItemFile)
{
var offsetName = $"{offset}{entry.Name}";
var len = 80 - offsetName.Length;
if (len <= 0)
{
len = 1;
}
var fill = GetFillString(len);
logger.LogInfo($"{offsetName}{fill}{entry.Size} b\t{entry.Mode:X}\t{entry.EntryType}");
}
}
}
}
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnDeleteDirectoryFormat, path, e.Message));
}
}
private static Stream NvOpenRead(QcdmManager manager, ushort nvItemId)
{
try
{
var data = manager.Nv.Read(nvItemId);
return(new MemoryStream(data));
}
catch
{
return(null);
}
}
private EfsStoreItem(QcdmManager manager, string name, string uniqueKey, string path, bool isReadOnly,
Logger logger, LogLevel logLevel)
{
_manager = manager;
_name = name;
_uniqueKey = uniqueKey;
_path = path;
_isReadOnly = isReadOnly;
_logger = logger;
_logLevel = logLevel;
LockingManager = new EfsStoreLockingManager();
}
public static void PhoneDeleteDirectory(QcdmManager manager, string path, bool recursive, Logger logger)
{
try
{
if (!string.IsNullOrEmpty(path))
{
var p = path;
if (p[p.Length - 1] == '/')
{
p = p.Substring(0, p.Length - 1);
}
if (recursive)
{
var ind = p.LastIndexOf('/');
if (ind >= 0)
{
var entries = PhoneOpenDirectory(manager, p, logger);
if (entries != null)
{
foreach (var entry in entries)
{
if (entry.EntryType == DirectoryEntryType.Directory)
{
var dirPath = $"{p}/{entry.Name}";
PhoneDeleteDirectory(manager, dirPath, true, logger);
continue;
}
if (entry.EntryType == DirectoryEntryType.File ||
entry.EntryType == DirectoryEntryType.ItemFile)
{
var filePath = $"{p}/{entry.Name}";
PhoneDeleteFile(manager, filePath, logger);
}
}
}
}
manager.Efs.DeleteDirectory(p);
}
else
{
manager.Efs.DeleteDirectory(p);
}
}
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnDeleteDirectoryFormat, path, e.Message));
}
}
private QcdmManager OpenQcdmManager()
{
var manager = new QcdmManager(_config.Port, _config.Baudrate, 5000);
if (_config.Port != manager.PortName)
{
_logger.LogInfo(Strings.QcdmUseComPortFormat, manager.PortName);
}
manager.Open();
manager.SendPassword(_config.Password);
manager.SendSpc(_config.Spc);
return(manager);
}
public static Dictionary <string, object> PhoneLoadItems(QcdmManager manager, int subscription, Logger logger, bool verbose,
HashSet <string> configItems)
{
var items = new Dictionary <string, object>();
foreach (var filePath in ItemsFactory.SupportedEfsFilePaths)
{
var realFilePath = PathUtils.GetEfsFilePath(filePath, subscription);
var itemType = ItemsFactory.GetEfsFileType(filePath);
if (configItems == null || configItems.Contains(itemType.Name))
{
if (manager.Efs.FileExists(realFilePath))
{
using (var stream = FileUtils.PhoneOpenReadMemory(manager, realFilePath))
{
if (verbose)
{
logger.LogInfo(string.Format(Strings.QcdmProcessingFormat, filePath));
}
var item = ItemsBinarySerializer.Deserialize(stream, itemType);
items.Add(itemType.Name, item);
stream.Close();
}
}
}
}
foreach (var nvItemId in ItemsFactory.SupportedNvItemIds)
{
var itemType = ItemsFactory.GetNvItemType(nvItemId);
if (configItems == null || configItems.Contains(itemType.Name))
{
using (var stream = NvOpenRead(manager, (ushort)nvItemId))
{
if (stream != null)
{
if (verbose)
{
logger.LogInfo(string.Format(Strings.QcdmProcessingFormat, itemType.Name));
}
var item = ItemsBinarySerializer.Deserialize(stream, itemType);
items.Add(itemType.Name, item);
stream.Close();
}
}
}
}
return(items);
}
private static void PhoneDownloadFile(QcdmManager manager, DirectoryEntry entry, string efsPath,
string computerPath, bool noExtraData, Logger logger)
{
try
{
var entryName = entry.Name;
var path1 = $"{efsPath}{entryName}";
var path2 = PathUtils.BuildPath(computerPath, entryName, entry.Mode, entry.EntryType, noExtraData);
PhoneReadFile(manager, path1, path2, logger);
}
catch (Exception e)
{
logger.LogError(string.Format(Strings.QcdmErrorOnDownloadFormat, efsPath, e.Message));
}
}
public static Stream PhoneItemCreateWrite(QcdmManager manager, string path, int permission, Logger logger)
{
var efs = manager.Efs;
if (efs.FileExists(path))
{
efs.DeleteFile(path);
}
var directoryPath = PathUtils.GetDirectoryName(path);
if (!efs.FileExists(directoryPath))
{
PhoneCreateDirectory(manager, directoryPath, true, logger);
}
return(new QcdmManagerItemWriteStreamAdapter(manager, path, permission));
}
private static bool CheckQualcommPort(string port, int baudrate, bool _hdlcSendControlChar, bool ignoreUnsupportedCommands, Logger logger)
{
try
{
using (var manager = new QcdmManager(port, baudrate, 500, _hdlcSendControlChar, ignoreUnsupportedCommands, logger))
{
manager.Open();
var version = manager.Version;
manager.Close();
return(true);
}
}
catch
{
}
return(false);
}
private QcdmManager OpenQcdmManager()
{
var manager = new QcdmManager(_config.Port, _config.Baudrate, 7000,
_config.HdlcSendControlChar, _config.IgnoreUnsupportedCommands, _logger);
if (_config.Port != manager.PortName)
{
_logger.LogInfo(Strings.QcdmUseComPortFormat, manager.PortName);
}
manager.Open();
manager.SendPassword(_config.Password);
manager.SendSpc(_config.Spc);
manager.DisableLogs();
manager.DisableMessages();
return(manager);
}
