Beispiel #1
0
        /// <summary>
        /// Метод проверки и инициализации окружения утилиты
        /// </summary>
        /// <returns>True если проверка и инициализация успешна</returns>
        public static bool Init()
        {
            System.Windows.Resources.StreamResourceInfo sri = Application.GetResourceStream(new Uri("pack://application:,,,/Tools.zip"));
            if (sri != null)
            {
                using (Stream s = sri.Stream)
                {
                    Zipper.UnpackZIP(s, ToolsPath);
                }
            }

            //Удаляем старый лог-файл
            logFile = Path.Combine(AppPath, logFile);
            if (File.Exists(logFile))
            {
                try { File.Delete(logFile); }
                catch { }
            }

            //Инициализация процесса JRE
            string JavaLocation = GetJavaInstallationPath();

            if (string.IsNullOrEmpty(JavaLocation))
            {
                Log("Java Runtime Environment не найден. Завершение.");
                MessageBox.Show("Для работы приложения требуется Java Runtime Environment", "Java Runtime Environment", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                return(false);
            }
            else
            {
                Log(string.Format("Java Runtime Environment найден по пути \"{0}\"", JavaLocation));
                javaProc.StartInfo.FileName               = Path.Combine(JavaLocation, "bin", "java.exe");
                javaProc.StartInfo.UseShellExecute        = false;
                javaProc.StartInfo.CreateNoWindow         = true;
                javaProc.StartInfo.RedirectStandardOutput = true;
            }

            signerFile = Path.Combine(ToolsPath, signerFile);
            if (!File.Exists(signerFile))
            {
                Log(string.Format(STR_FILE_NOT_EXIST, signerFile));
                MessageBox.Show(string.Format(STR_FILE_NOT_EXIST, signerFile), STR_FILE_NOT_EXIST_CAPTION, MessageBoxButton.OK, MessageBoxImage.Error);
                return(false);
            }

            //Инициализация процесса keytool
            string aapt = Path.Combine(ToolsPath, aaptFile);

            if (!File.Exists(aapt))
            {
                Log(string.Format(STR_FILE_NOT_EXIST, aaptFile));
                MessageBox.Show(string.Format(STR_FILE_NOT_EXIST, aaptFile), STR_FILE_NOT_EXIST_CAPTION, MessageBoxButton.OK, MessageBoxImage.Error);
                return(false);
            }
            else
            {
                aaptProc.StartInfo.FileName               = aapt;
                aaptProc.StartInfo.UseShellExecute        = false;
                aaptProc.StartInfo.CreateNoWindow         = true;
                aaptProc.StartInfo.RedirectStandardOutput = true;
            }

            //Инициализация зипалигнера
            alignerFile = Path.Combine(ToolsPath, alignerFile);
            if (!File.Exists(alignerFile))
            {
                Log(string.Format(STR_FILE_NOT_EXIST, alignerFile));
                MessageBox.Show(string.Format(STR_FILE_NOT_EXIST, alignerFile), STR_FILE_NOT_EXIST_CAPTION, MessageBoxButton.OK, MessageBoxImage.Error);
                return(false);
            }
            else
            {
                zaProc.StartInfo.FileName               = alignerFile;
                zaProc.StartInfo.UseShellExecute        = false;
                zaProc.StartInfo.CreateNoWindow         = true;
                zaProc.StartInfo.RedirectStandardOutput = true;
            }

            //Инициализация процесса keytool
            string ktFile = Path.Combine(JavaLocation, "bin", keytoolFile);

            if (!File.Exists(ktFile))
            {
                Log(string.Format(STR_FILE_NOT_EXIST, ktFile));
                MessageBox.Show(string.Format(STR_FILE_NOT_EXIST, ktFile), STR_FILE_NOT_EXIST_CAPTION, MessageBoxButton.OK, MessageBoxImage.Error);
                return(false);
            }
            else
            {
                ktProc.StartInfo.FileName               = ktFile;
                ktProc.StartInfo.UseShellExecute        = false;
                ktProc.StartInfo.CreateNoWindow         = true;
                ktProc.StartInfo.RedirectStandardOutput = true;
            }

            //Читаем все сертификаты, доступные в папке Tools
            foreach (string pemFile in Directory.GetFiles(ToolsPath, "*.pem"))
            {
                Log(string.Format("Добавляем сертификат \"{0}\"", pemFile));
                if (CertReader.ReadCert(pemFile, true) == null)
                {
                    Log(string.Format("Сертификат не был добавлен\"{0}\". Отсутствует файл pk8.", pemFile));
                }
            }

            //Читаем все сертификаты, доступные в папке с программой Tools
            foreach (string pemFile in Directory.GetFiles(AppPath, "*.pem"))
            {
                Log(string.Format("Добавляем сертификат \"{0}\"", pemFile));
                if (CertReader.ReadCert(pemFile, true) == null)
                {
                    Log(string.Format("Сертификат не был добавлен\"{0}\". Отсутствует файл pk8.", pemFile));
                }
            }

            return(true);
        }
Beispiel #2
0
        /// <summary>
        /// Считывает информацию о файле и его сертификате
        /// </summary>
        /// <param name="fPath">Путь до файла</param>
        /// <returns>Структура информации о пакете</returns>
        public PackageInfo ReadFile(string fPath)
        {
            Environment.Log(string.Format("Читаем файл \"{0}\"...", fPath));
            if (!File.Exists(fPath))
            {
                Environment.Log("Файл не существует");
                return(null);
            }

            //Ищем пакет в коллекции
            PackageInfo pInfoStored = _Packages.FirstOrDefault(p => p.Path == fPath);

            if (pInfoStored == null)
            {
                PackageInfo pInfo = new PackageInfo();
                pInfo.Path = fPath;
                pInfo.Name = Path.GetFileName(fPath);
                pInfo.Cert = CertReader.ReadZip(fPath);
                pInfo.Icon = IconHelper.GetApkIcon(fPath);

                if (pInfo.Icon == null)
                {
                    if (Path.GetExtension(fPath) == ".apk")
                    {
                        pInfo.Icon = ApkIcon;
                        pInfo.Type = PackageInfo.FileType.APK;
                    }
                    else if (Path.GetExtension(fPath) == ".jar")
                    {
                        pInfo.Icon = JarIcon;
                        pInfo.Type = PackageInfo.FileType.JAR;
                    }
                }

                if (Dispatcher != null && !Dispatcher.CheckAccess())
                {
                    Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new PackageInfoDelegate((_pInfo) =>
                    {
                        if (_pInfo.Type == PackageInfo.FileType.APK)
                        {
                            _ApkPackages.Add(_pInfo);
                        }
                        else if (_pInfo.Type == PackageInfo.FileType.JAR)
                        {
                            _JarPackages.Add(_pInfo);
                        }
                        _Packages.Add(_pInfo);
                        OnPackagesChanged();
                    }), pInfo);
                }
                else
                {
                    if (pInfo.Type == PackageInfo.FileType.APK)
                    {
                        _ApkPackages.Add(pInfo);
                    }
                    else if (pInfo.Type == PackageInfo.FileType.JAR)
                    {
                        _JarPackages.Add(pInfo);
                    }
                    _Packages.Add(pInfo);
                    OnPackagesChanged();
                }

                return(pInfo);
            }
            else
            {
                return(pInfoStored);
            }
        }