Exemple #1
0
        private async Task ExecuteLoad(IReadOnlyList <StorageFile> selectedFiles)
        {
            this.allCameraPictures.Clear();
            int cameraCollectionsCount = 0;

            foreach (var file in selectedFiles)
            {
                if (!file.ContentType.Contains("image"))
                {
                    break;
                }

                var cameraInfo = await CameraMetaReader.GetCameraMeta(file);

                var cameraPictures = CameraMetaReader.GetCameraPicturesModel(this.allCameraPictures, cameraInfo);

                if (this.allCameraPictures.Count != cameraCollectionsCount)
                {
                    this.RecalculateCameraPicturesGridHeight();
                    cameraCollectionsCount++;
                }

                var picture = await PictureMetaReader.CreateNewPictureModel(file);

                cameraPictures.Add(picture);
            }

            this.SetReadResultMessage();
        }
Exemple #2
0
        private async Task ExecuteLoad(IReadOnlyList <StorageFile> selectedFiles)
        {
            this.allPictures.Clear();

            foreach (var file in selectedFiles)
            {
                if (!file.ContentType.Contains("image"))
                {
                    break;
                }

                var cameraInfo = await CameraMetaReader.GetCameraMeta(file);

                if (cameraInfo[0] == UnknownMeta.CameraManufacturer && cameraInfo[1] == UnknownMeta.CameraModel)
                {
                    this.picturesWithInvalidMeta++;
                }

                var picture = await PictureMetaReader.CreateNewPictureModel(file);

                this.allPictures.Add(picture);
            }

            this.SetReadResultMessage();
        }
        private async Task SplitValidAndInvalidPictures(
            List <object> picturesDataForRename, List <PictureModel> sortedPicturesByDateTime)
        {
            var validCameraPictures   = new List <PictureModel>();
            var invalidCameraPictures = new CameraPicturesModel();

            invalidCameraPictures.CameraManufacturer = UnknownMeta.CameraManufacturer;
            invalidCameraPictures.CameraModel        = UnknownMeta.CameraModel;

            foreach (var picture in sortedPicturesByDateTime)
            {
                var cameraInfo = await CameraMetaReader.GetCameraMeta(picture.StorageFile);

                if (cameraInfo[0] == UnknownMeta.CameraManufacturer && cameraInfo[1] == UnknownMeta.CameraModel)
                {
                    invalidCameraPictures.Add(picture);
                }
                else
                {
                    validCameraPictures.Add(picture);
                }
            }

            picturesDataForRename.Add(validCameraPictures);
            picturesDataForRename.Add(invalidCameraPictures);
        }
        public override async void LoadState(object navParameter, Dictionary <string, object> viewModelState)
        {
            if (viewModelState != null)
            {
                this.allPictures                  = viewModelState["allPictures"] as ObservableCollection <PictureModel>;
                this.cameraTimeSynchroniser       = viewModelState["cameraTimeSynchroniser"] as CameraTimeSynchroniserModel;
                this.fileNameTemplate             = viewModelState["fileNameTemplate"] as FileNameTemplateModel;
                this.picturesWithInvalidMetaCount = (int)viewModelState["picturesWithInvalidMetaCount"];
            }
            else if (navParameter != null)
            {
                var navParameterAsList = navParameter as List <object>;

                var allPicturesAsNavParameter = navParameterAsList[0] as List <PictureModel>;
                this.picturesWithInvalidMetaCount = (int)navParameterAsList[1];

                var sortedByDatePictures = allPicturesAsNavParameter.OrderBy(p => p.StorageFile.DateCreated).ToList();
                if (picturesWithInvalidMetaCount > 0)
                {
                    var picturesWithInvalidMeta = new List <PictureModel>();
                    foreach (var picture in sortedByDatePictures)
                    {
                        var cameraInfo = await CameraMetaReader.GetCameraMeta(picture.StorageFile);

                        if (cameraInfo[0] == UnknownMeta.CameraManufacturer && cameraInfo[1] == UnknownMeta.CameraModel)
                        {
                            picturesWithInvalidMeta.Add(picture);
                        }
                        else
                        {
                            this.allPictures.Add(picture);
                        }
                    }

                    foreach (var picture in picturesWithInvalidMeta)
                    {
                        this.allPictures.Add(picture);
                    }
                }

                this.SetPicturesForTimeMerging();
            }

            this.AddShareContract();
            this.IsReadyToProceed = true;
            this.IsAllLoaded      = true;
        }