Just Developer Blog, заметки с тегом: Xamarin

Использование QLPreviewController для просмотра файлов (iOS)

Wed, 13 Jan 2016 22:10:14 +0300

Для реализации просмотра файлов различных форматов (изображения, word, excel, txt, медиа и т. п.) в iOS существует очень удобный класс QLPreviewController. Для его удобного использования необходимо сделать следующее:

Создать класс-наследник QLPreviewController, который инкапсулирует все детали реализации
Создать класс QLPreviewControllerDataSource, который будет являться источником данных для контроллера
Создать классы-наследники QLPreviewItem, которые будут хранить информацию о просматриваемом элементе

Без лишних слов сразу взглянем на код контроллера

/// <summary>
/// Контроллер, который позволяет отобразить документы (изображения, ворд, экзель, пдф и т.п.) в виде превью
/// поддерживает несколько документов для отображения
/// </summary>
public class QuickLookPreviewController : QLPreviewController
{
    /// <summary>
    /// Отобразить список NSUrl'ов
    /// </summary>
    /// <returns><c>true</c>, if urls was previewed, <c>false</c> otherwise.</returns>
    /// <param name="urls">Urls.</param>
    public bool PreviewUrls(params NSUrl[] urls)
    {
        List<QLPreviewItem> items = new List<QLPreviewItem>();
        foreach (NSUrl url in urls)
        {
            QLPreviewItemNsUrl item = new QLPreviewItemNsUrl(url);
            if (QLPreviewController.CanPreviewItem(item))
            {
                items.Add(item);
            }
        }

        return PreviewItems(items.ToArray());
    }

    /// <summary>
    /// Отобразить список QLPreviewItem
    /// </summary>
    /// <returns><c>true</c>, if items was previewed, <c>false</c> otherwise.</returns>
    /// <param name="items">Items.</param>
    public bool PreviewItems(params QLPreviewItem[] items)
    {
        if (items.Length > 0)
        {
            DataSource = new PreviewControllerDataSource(items);
            return true;
        }

        return false;
    }

    /// <summary>
    /// QL Preview источник данных
    /// </summary>
    private class PreviewControllerDataSource : QLPreviewControllerDataSource
    {
        private QLPreviewItem[] _items = new QLPreviewItem[0];

        public PreviewControllerDataSource(params QLPreviewItem[] items)
        {
            _items = items;
        }

        public override nint PreviewItemCount(QLPreviewController controller)
        {
            return _items.Length;
        }

        public override IQLPreviewItem GetPreviewItem(QLPreviewController controller, nint index)
        {
            return _items[index];
        }
    }

    /// <summary>
    /// QL Preview Item, принимающий NSUrl
    /// </summary>
    public class QLPreviewItemNsUrl : QLPreviewItem
    {
        private NSUrl _documentUrl;

        public QLPreviewItemNsUrl(NSUrl documentUrl)
        {
            _documentUrl = documentUrl;
        }

        public override string ItemTitle
        {
            get
            {
                return _documentUrl.LastPathComponent;
            }
        }
        public override NSUrl ItemUrl
        {
            get
            {
                return _documentUrl;
            }
        }
    }

    /// <summary>
    /// QL Preview Item, принимающий имя и путь к файлу из файловой системы
    /// </summary>
    public class QLPreviewItemFileSystem : QLPreviewItem
    {
        string _fileName, _filePath;

        public QLPreviewItemFileSystem(string fileName, string filePath)
        {
            _fileName = fileName;
            _filePath = filePath;
        }

        public override string ItemTitle
        {
            get
            {
                return _fileName;
            }
        }
        public override NSUrl ItemUrl
        {
            get
            {
                return NSUrl.FromFilename(_filePath);
            }
        }
    }

    /// <summary>
    /// QL Preview Item, принимающий имя ипуть к файлу из бандла
    /// </summary>
    public class QLPreviewItemBundle : QLPreviewItem
    {
        string _fileName, _filePath;
        public QLPreviewItemBundle(string fileName, string filePath)
        {
            _fileName = fileName;
            _filePath = filePath;
        }

        public override string ItemTitle
        {
            get
            {
                return _fileName;
            }
        }
        public override NSUrl ItemUrl
        {
            get
            {
                var documents = NSBundle.MainBundle.BundlePath;
                var lib = Path.Combine(documents, _filePath);
                var url = NSUrl.FromFilename(lib);
                return url;
            }
        }
    }
}

Использовать данный код можно следующим образом:

QuickLookPreviewController previewController = new QuickLookPreviewController();
if (previewController.PreviewUrls(new NSUrl[]{ fileUrl }))
{
    this.NavigationController.PushViewController(previewController, true);
}

Создание и удаление записей в календаре (iOS)

Wed, 06 Jan 2016 18:38:03 +0300

Многие приложения используют очень полезную фишку ОС от Apple как создание кастомных записей и календарей. Сегодня мы рассмотрим пример реализации класса-хэлпера, позволяющего создавать и удалять записи в кастомном календаре.

Вся работа с календарем строится через фреймворк EventKit, при этом последовательность действий для создания записи примерно следующая:

Создать экземпляра класса EKEventStore
Запросить через него разрешение на работу с календарем
В completionHandler реализовать код, который будет создавать запись
При создании записи необходимо сначала найти наш кастомный календарь EKCalendar (или создать его, если его еще нет)
Создать экземпляр класса EKEvent (это и будет наша запись) и установить для него заголовок, сопроводительный текст, время начала и окончания
Создать и добавить ремайндер (экземпляр класса EKAlarm), который описывает когда должно сработать напоминание о записи

Более подробно можно понять, посмотрев код:

public class EventKitCalendarHelper
{
    /// <summary>
    /// Имя кастомного календаря
    /// </summary>
    public static string CalendarTitle = "CalendarTitle";

    /// <summary>
    /// Варианты срабатывания напоминания для записи в календаре
    /// </summary>
    public enum AlarmTime
    {
        None = 0,
        FifteenMinutesBefore = -15*60,
        HalfAnHourBefore = -30*60,
        AnHourBefore = -60*60,
        TwoHoursBefore = -2*60*60,
        ThreeHoursBefore = -3*60*60
    }

    /// <summary>
    /// Добавляет запись в календаре
    /// </summary>
    /// <param name="eventTitle">Event title.</param>
    /// <param name="dateStart">Date start.</param>
    /// <param name="timeLength">Time length.</param>
    /// <param name="time">Time.</param>
    public static void AddCalendarEvent(string eventTitle, DateTime dateStart, TimeSpan timeLength, string eventNotes = "", AlarmTime time = AlarmTime.None)
    {
        if (string.IsNullOrEmpty(eventTitle))
        {
            return;
        }

        EKEventStore store = new EKEventStore();
        store.RequestAccess(EKEntityType.Event, (granted, err) =>
            {
                if (!granted)
                {
                    return;
                }

                EKEvent entry = EKEvent.FromStore(store);
                entry.Title = eventTitle;
                entry.Notes = eventNotes;
                entry.StartDate = dateStart.DateTimeToNSDate();
                entry.EndDate = dateStart.Add(timeLength).DateTimeToNSDate();

                //ищем наш кастомный календарь, если мы его не находим - создаем новый
                EKCalendar calendar = FindOrCreateCalendar(store, true);
                if(calendar == null)
                {
                    return;
                }

                entry.Calendar = calendar;

                //создаем ремайндер, если он требуется
                if (time != AlarmTime.None)
                {
                    entry.AddAlarm(EKAlarm.FromTimeInterval((int)time));
                }

                err = null;
                store.SaveEvent(entry, EKSpan.ThisEvent, out err);
            });
    }

    /// <summary>
    /// Находит или создает кастомный календарь
    /// </summary>
    /// <returns>The or create calendar.</returns>
    /// <param name="store">Store.</param>
    /// <param name="createIfDoesntExist">If set to <c>true</c> create if doesnt exist.</param>
    private static EKCalendar FindOrCreateCalendar(EKEventStore store, bool createIfDoesntExist = false)
    {
        NSError err = null;

        EKCalendar calendar = store.Calendars.Where(x => x.Title == CalendarTitle).FirstOrDefault();
        if (calendar == null && createIfDoesntExist)
        {
            err = null;
            calendar = EKCalendar.Create(EKEntityType.Event, store);
            calendar.Title = CalendarTitle;

            EKSource localSource = store.Sources.Where(x => x.SourceType == EKSourceType.Local).FirstOrDefault();
            calendar.Source = localSource;

            store.SaveCalendar(calendar, true, out err);
        }

        return calendar;
    }
}

С удалением событий дела обстоят интереснее. При создании события у него есть строковое поле EventIdentifier, его можно где-то сохранить и использовать позже для удаления записи. Либо можно найти все записи при помощи специальным образом сформированного предиката и удалить их. Рассмотрим второй вариант.

/// <summary>
/// Удаляет записи в календаре, которые соответствуют выбранному интервалу времени
/// </summary>
/// <param name="dateStart">Date start.</param>
/// <param name="timeLength">Time length.</param>
public static void RemoveCalendarEvent(DateTime dateStart, TimeSpan timeLength, string title = "")
{
    EKEventStore store = new EKEventStore();
    store.RequestAccess(EKEntityType.Event, (granted, err) =>
        {
            if (!granted)
            {
                return;
            }

            //ищем наш кастомный календарь
            EKCalendar calendar = FindOrCreateCalendar(store);
            if (calendar == null)
            {
                return;
            }

            //создаем предикат для поиска эвентов в нашем календаре
            NSPredicate predicate = store.PredicateForEvents(dateStart.DateTimeToNSDate(), dateStart.Add(timeLength).DateTimeToNSDate(), new EKCalendar[]{ calendar });
            EKEvent[] entries = store.EventsMatching(predicate);

            if (entries == null || entries.Length == 0)
            {
                return;
            }

            //если нужно - профильтруем элементы календаря по заголовку
            if (!string.IsNullOrEmpty(title))
            {
                entries = entries.Where(x => x.Title == title).ToArray();
            }

            if (entries == null || entries.Length == 0)
            {
                return;
            }

            //проходимся по всем найденным эвентам и удаляем их
            foreach (EKEvent entry in entries)
            {
                err = null;
                store.RemoveEvent(entry, EKSpan.ThisEvent, true, out err);
            }
        });
}

Использование NSUrlSession для загрузки файлов (iOS)

Sun, 03 Jan 2016 10:53:01 +0300

При разработке мобильного приложения очень часто возникает необходимость организовать загрузку файла по сети. При этом если разработка ведется на Xamarin высоко желание использовать стандартный WebClient для этих целей. Все бы ничего, но при использовании WebClient возникает несколько сложностей, например:

Не высокая производительность
Прерывание загрузки при блокировке устройства или уходе приложения в бекграунд

Для решения вопроса с загрузкой файлов наиболее правильным способом будет кардинально переписать загрузку на использование NSUrlSession.

NSUrlSession — это системный механизм iOS, позволяющий организовать длительные процессы загрузки и заливки данных по сети, при этом система сама правильно обработает обрывы связи, докачает файл, если это возможно и уведомит приложение о результате.

Чтобы использовать NSUrlSession нам потребуется сделать следующее:

Создать класс-хэлпер, который будет инкапсулировать всю логику работы с NSUrlSession
Создать класс-делегат наследник NSUrlSessionDownloadDelegate, который будет уведомлять внешний код о прогрессе загрузки файла, а так же об окончании загрузки
Создать экземпляр класса NSUrlSession и присвоить ему делегат
Для каждого URL файла создать NSUrlRequest и NSUrlSessionDownloadTask, и запустить скачивание
Так же необходимо позаботиться о том, чтобы не потерять информацию о том, какому Url соответствует какой NSUrlSessionDownloadTask, чтобы потом корректно сообщать внешнему коду о ходе скачивания

Далее код готового решения с комментариями о деталях реализации:

/// <summary>
/// Класс, который реализует всю работу с механизмом NSUrlSession для реализации загрузки файлов в фоновом режиме
/// </summary>
public class DownloadSession
{
    /// <summary>
    /// Создаем экземпляр конфигурации для сессии (с таким ID сессия может быть только одна в приложении)
    /// </summary>
    private static NSUrlSessionConfiguration _downloadConfiguration = NSUrlSessionConfiguration.BackgroundSessionConfiguration("com.appid.background.download");

    /// <summary>
    /// Класс-делегат, инкапсулирует всю логику по уведомлению внешнего кода о состоянии загрузки, а так же занимается менеджментом хранения ссылок на скачиваемые файлы
    /// </summary>
    public sealed class ChatBackgroundSessionDelegate : NSUrlSessionDownloadDelegate
    {
        /// <summary>
        /// Словарь, который хранит соответствие - таск загрузки <--> url файла
        /// </summary>
        public Dictionary<NSUrlSessionDownloadTask, string> QueueHolder { get; private set; }

        public delegate void DownloadingCompleteDelegate(string url, NSUrl tempFileLocation);
        public delegate void DownloadProgressDelegate(string url, int progressPercent);

        /// <summary>
        /// Экшн, который будет вызываться при окончании загрузки файла (в параметрах будут url файла и NSUrl на временный скачанный файл)
        /// </summary>
        public DownloadingCompleteDelegate CompleteAction { get{ return _completeAction; } set{ _completeAction = value; } }
        private DownloadingCompleteDelegate _completeAction;

        /// <summary>
        /// Экшн, который будет вызываться при изменении прогресса скачивания файла (в параметрах будет url файла и процент скачивания)
        /// </summary>
        public DownloadProgressDelegate ProgressDelegate { get{ return _progressDelegate; } set{ _progressDelegate = value; } }
        private DownloadProgressDelegate _progressDelegate;

        /// <summary>
        /// Конструктор, который создает словарь-очередь и присваивает все необходимые экшны
        /// </summary>
        public ChatBackgroundSessionDelegate(DownloadingCompleteDelegate downloadCompleteAction, DownloadProgressDelegate progressDelegate = null)
        {
            _completeAction = downloadCompleteAction;
            _progressDelegate = progressDelegate;

            QueueHolder = new Dictionary<NSUrlSessionDownloadTask, string>();
        }

        /// <summary>
        /// Метод, вызывается системой при изменении прогресса скачивания файлов
        /// </summary>
        public override void DidWriteData (NSUrlSession session, NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)
        {
            if (_progressDelegate == null || !QueueHolder.ContainsKey(downloadTask))
            {
                return;
            }

            //если в очереди найден такой файл и экшн был передан извне - то вызываем экшн в основном потоке и вычисляем процент скачивания файла
            InvokeOnMainThread(() =>
                {
                    _progressDelegate.Invoke(QueueHolder[downloadTask], Convert.ToInt32(totalBytesWritten * 100 / totalBytesExpectedToWrite));
                });
        }

        /// <summary>
        /// Метод, который вызывается при завершении загрузки файла
        /// </summary>
        public override void DidFinishDownloading(NSUrlSession session, NSUrlSessionDownloadTask downloadTask, NSUrl location)
        {
            if (_completeAction == null || !QueueHolder.ContainsKey(downloadTask))
            {
                return;
            }

            InvokeOnMainThread(() =>
                {
                    _completeAction.Invoke(QueueHolder[downloadTask], location);
                });
        }
    }

    private ChatBackgroundSessionDelegate _delegate;
    private NSUrlSession _downloadSession;

    /// <summary>
    /// Конструктор класса-холдера
    /// </summary>
    public DownloadSession(ChatBackgroundSessionDelegate.DownloadingCompleteDelegate downloadCompleteAction,
        ChatBackgroundSessionDelegate.DownloadProgressDelegate progressDelegate = null)
    {
        //создаем делегат
        _delegate = new ChatBackgroundSessionDelegate(downloadCompleteAction, progressDelegate);

        //создаем сессию (при этом если сессия с такой конфигурацией уже есть в системе - то новая сессия создана не будет, а в переменную попадет старая сессия)
        _downloadSession = NSUrlSession.FromConfiguration(
            _downloadConfiguration,
            _delegate,
            new NSOperationQueue());
    }

    /// <summary>
    /// Стартует процесс загрузки
    /// </summary>
    /// <param name="url">URL.</param>
    /// <param name="file">File.</param>
    /// <param name="message">Message.</param>
    public void StartDownload(string url)
    {
        if (string.IsNullOrEmpty(url))
        {
            return;
        }

        NSUrl nsurl = NSUrl.FromString(new NSString(url).CreateStringByAddingPercentEscapes(NSStringEncoding.UTF8));
        NSUrlRequest request = NSUrlRequest.FromUrl(nsurl);
        NSUrlSessionDownloadTask task = _downloadSession.CreateDownloadTask(request);

        //нужно именно попробовать создать сессию и только после этого взяь ее делегат, кастануть его к нужному типу и забиндить реквесты
        //делаем так, потому что сессия глобально в системе создается только одна и при попытке повторного ее создания - новый делегат просто не присваивается :)
        //экшны копируются из нового делегата в старый, потому что мы никак физически не можем заменить делегат (он только для чтения)
        if (_delegate != (ChatBackgroundSessionDelegate)_downloadSession.Delegate)
        {
            ChatBackgroundSessionDelegate newDelegate = (ChatBackgroundSessionDelegate)_downloadSession.Delegate;
            newDelegate.CompleteAction = _delegate.CompleteAction;
            newDelegate.ProgressDelegate = _delegate.ProgressDelegate;
        }
        _delegate = (ChatBackgroundSessionDelegate)_downloadSession.Delegate;

        //добавляем наш Url и таск в очередь
        _delegate.QueueHolder.Add(task, url);

        //стартуем загрузку
        task.Resume();
    }
}

Использовать все это хозяйство можно следующим образом:

//создаем сессию загрузки данных
DownloadSession session = new DownloadSession((url, tempFileLocation) =>
    {
        //если завершена загрузка файла - сохраняем его на диск
        if (item.url == url)
        {
            /////////////////
        }
    }, (url, percent) =>
    {
        if (item.url == url)
        {
            //отображаем прогресс загрузки
        }
    });

//стартуем загрузку
session.StartDownload(item.url);

Реализация уведомлений-индикаторов для загружаемых на сервер файлов (Android)

Sun, 20 Dec 2015 12:53:09 +0300

При необходимости загрузить файла на сервер из приложения встает вопрос об индикации процесса загрузки. Если дизайн позволяет то можно отобразить диалог прогресс бара (при этом заблокировать интерфейс пользователя). Но на мой взгляд более интересным вариантом индикации являются уведомления в статус баре системы, которые нельзя смахнуть.

При реализации такого подхода может возникнуть несколько проблем:

Как создать уведомление для каждого загружаемого файла (если например существует возможность единовременно загружать несколько файлов)
Как программно отменить уведомление после завершения процесса загрузки на сервер

Для решения этих проблем необходимо знать как система индексирует уведомления, создаваемые приложением. Каждое приложение может создать сколь угодно много уведомлений, но чтобы иметь возможность обновить определенное уведомление, либо отменить его — необходимо присвоить каждому из уведомлений свой уникальный ID. Ниже код реализации создания уведомления при старте загрузки файла на сервер и его отмены, по окончании загрузки:

//Кеш, хранящий список id активных на данный момент уведомлений
private List<int> _notificationCache = new List<int>();

private void UploadFile()
{
    //получим рандомный ID для уведомления, при этом он не должен пересекаться с уже существующими (для этого используем кеш)
    Random r = new Random(System.Environment.TickCount);
    int notificationId = 0;
    while (notificationId == 0 || _notificationCache.Contains(notificationId))
    {
        notificationId = r.Next(1, 1000);
    }
    _notificationCache.Add(notificationId);
    //
                
    Notification.Builder builder = new Notification.Builder(Activity);
    builder.SetSmallIcon(Resource.Drawable.file_32x32)
        //устанавливаем заголовок для уведомления
        .SetContentTitle(filename)
        //в дескрипшне будет храниться наша строка "Загружаю файл на сервер..."
        .SetContentText(Activity.GetString(Resource.String.attachement_uploading))
        .SetAutoCancel(false)
        //запрещаем отмену уведомления пользователем
        .SetOngoing(true)
        //разрешаем уведомлению появиться в статус баре, мигать светодиодом и т.п.
        .SetDefaults(NotificationDefaults.All);

    NotificationManager manager = (NotificationManager)Activity.GetSystemService(Activity.NotificationService);
    manager.Notify(notificationId, builder.Build());

    //////////////////////////////////////////
    // ... код загрузки файла на сервер ... //
    //////////////////////////////////////////

    //отменяем уведомление и удаляем его ID из кеша
    manager.Cancel(notificationId);
    _notificationCache.Remove(notificationId);
}

Использование DownloadManager для скачивания файлов из сети (Android)

Mon, 07 Dec 2015 22:12:40 +0300

В прошлой статье я рассказывал о том, как скачивать файлы из сети и сохранять их на диск, а так же использовать MediaScanner для того, чтобы сделать файлы доступными другим приложениям (например галерее, если это фотография или видео).

Сегодня же хотелось бы рассказать о более интересном и предпочтительном способе скачивания файлов — использовании системного сервиса DownloadManager.

DownloadManager это такой сервис платформы Android, который предоставляет весь спектр функциональности, связанной с загрузкой файлов. Он сам начнет скачивание, корректно отреагирует на обрыв связи или смену типа сети, запустит скачивание по новой (если был обрыв связи), создаст и отобразит уведомление о загрузке файла, уведомит MediaScanner о том, что файл загружен и многое другое.

Для корректного использования DownloadManager нам понадобится:

Создать свой класс — наследник BroadcastReceiver, в котором мы будем реагировать на интенты, отсылаемые DownloadManager’ом;
Подготовить URI с ресурсом, который нужно загрузить;
Создать реквест с нашим URI и другими настройками DownloadManager;
Запустить скачивание.

Итак перво наперво — напишем класс-наследник BroadcastReceiver и реализуем логику, которая покажет Toast, когда наш файл скачается:

/// <summary>
/// Ресивер, который принимает информацию о состоянии загружаемых файлов приложением (задача только одна - отобразить сообщение об успешной загрузке)
/// </summary>
public class DownloadManagerReceiver : BroadcastReceiver
{
    public override void OnReceive(Context context, Intent intent)
    {
        if (intent.Action == DownloadManager.ActionDownloadComplete)
        {
            //это не совсем правильно с точки зрения производительности, лучше передать ссылку на менеджер извне
            DownloadManager downloadManager = (DownloadManager)context.GetSystemService(Activity.DownloadService);

            long downloadId = intent.GetLongExtra(DownloadManager.ExtraDownloadId, -1);
            if (downloadId == -1)
            {
                return;
            }

            DownloadManager.Query query = new DownloadManager.Query();
            query.SetFilterById(new long[]{ downloadId });

            ICursor cursor = downloadManager.InvokeQuery(query);
            if (cursor != null && cursor.MoveToFirst())
            {
                if (DownloadStatus.Successful == (DownloadStatus)cursor.GetInt(cursor.GetColumnIndex(DownloadManager.ColumnStatus)))
                {
                    string filename = cursor.GetString(cursor.GetColumnIndex(DownloadManager.ColumnTitle));
                    
                    Toast.makeText(context, string.Format(context.GetString(Resource.String.chat_attachement_succesfully_downloaded), filename), Toast.LENGTH_SHORT);
                }
            }

        }
    }
}

Далее необходимо создать и зарегистрировать наш ресивер:

protected override async void OnCreate(Bundle bundle)
{
    //код инициализации активности
    //...
    /////////

    //создаем ресивер для корректной обработки успешного скачивания файла
    _downloadManagerReceiver = new DownloadManagerReceiver();
    RegisterReceiver(_downloadManagerReceiver, new IntentFilter(DownloadManager.ActionDownloadComplete));
}

Последним этапом — необходимо получить ссылку на экземпляр сервиса DownloadService, настроить менеджер и запустить скачивание:

private void DownloadFile(string filename){
    DownloadManager downloadManager = (DownloadManager)GetSystemService(Activity.DownloadService);
    //реквест содержит URI файла и дополнительные настройки DownloadManager'а
    DownloadManager.Request request = new DownloadManager.Request(Android.Net.Uri.Parse("http://наш_url_для_скачивания"));

    //нотификейшн будет виден всегда, пока юзер не отменит его вручную или не кликнет
    request.SetNotificationVisibility(DownloadVisibility.VisibleNotifyCompleted);
    //задаем публичную директорию с загрузками и вторым параметром имя файла + расширение
    request.SetDestinationInExternalPublicDir(Android.OS.Environment.DirectoryDownloads, filename);
    //разрешаем сканить новый файл МедиаСканнеру
    request.AllowScanningByMediaScanner();

    //запускаем скачивание
    downloadManager.Enqueue(request);   
}

Вот и все, после старта скачивания менеджер создать нотификейшн со статусом скачивания, а после позволит открыть файл в приложении по-умолчанию.

Сохранение файлов из сети на диск в публичную директорию (Android)

Wed, 02 Dec 2015 22:06:16 +0300

Практически любому приложению, которое позволяет обмениваться контентом необходимо скачивать данные из сети и сохранять их на диск устройства. Существует два распространенных способа это сделать:

Скачать и сохранить файл вручную;
Использовать класс DownloadManager и доверить работу ему.

При этом скачанные файлы не будут видны приложениям на устройстве до тех пор, пока разработчик самостоятельно не сделает их доступными (либо до следующей перезагрузке устройства).

В этой статье мы рассмотрим ручной способ сохранения на диск применительно к Xamarin.Android. Более интересный вариант с использованием DownloadManager будет рассмотрен в другой статье.

Для начала необходимо получить массив байт файла из сети (например по его URL). Для этого можно использовать например простейший WebClient, написать примерно такой код:

string url = “url_к_нашему_файлу”;
byte[] dataBytes = new System.Net.WebClient().DownloadData(url);

Далее необходимо сохранить полученный массив байт как файл на диске. Для этого сначала необходимо получить путь до одной из публичных директорий, они могут быть следующими:

Environment.DirectoryMusic;
Environment.DirectoryPodcasts;
Environment.DirectoryRingtones;
Environment.DirectoryAlarms;
Environment.DirectoryNotifications;
Environment.DirectoryPictures;
Environment.DirectoryMovies;
Environment.DirectoryDownloads;
Environment.DirectoryDcim.

Назначение директорий вполне ясно из их названия, будем использовать Environment.DirectoryDownloads. Напишем следующий код (пояснение в комментариях):

//получаем путь к директории с загрузками
string dirPath = Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDownloads).AbsolutePath;
//если директории нет (такое может быть, да О_о, создадим ее)
if (!Directory.Exists(dirPath))
{
    Directory.CreateDirectory(dirPath);
}

//получаем путь до конечного файла в нашей директории, если он уже есть - удалим его
string filePath = Path.Combine(dirPath, file.Name);
if (File.Exists(filePath))
{
    File.Delete(filePath);
}

//записываем массив байт на диск
File.WriteAllBytes(filePath, fileBytes);

Почти готово, осталось только объявить системе о том, что на диске теперь есть новый файл, доступный всем вокруг. Для этого используется подсистема Android, которая называется MediaScanner. Существует несколько способов работы с МедиаСканнером, все они обладают разным уровнем гибкости и сложности. Мы воспользуемся самым простым — отправим широковещательный интент системе, МедиаСканнер его поймает и сделает добавит файл в свою базу.

//объявим МедиаСканеру о том, что появился новый файл
Intent mediaScannerIntent = new Intent(Intent.ActionMediaScannerScanFile);
mediaScannerIntent.SetData(Android.Net.Uri.FromFile(new Java.IO.File(filePath)));
SendBroadcast(mediaScannerIntent);

Применение констрейнтов для загруженного Xib в iOS

Tue, 24 Nov 2015 20:44:18 +0300

Очень часто возникает ситуация, когда необходимо переиспользовать часть интерфейса. Для решения этого вопроса в iOS лучше всего подходит вынесение элемента интерфейса в отдельный Xib-файл и последующая его загрузка из кода. Когда мы грузим Xib как ячейку таблицы — он скаллируется автоматически в зависимости от размера ячейки, но если загружать и добавлять его например в произвольный контроллер или View — то могут возникнуть сложности с масштабированием View из Xib при ресайзе родительской View.

Начиная с iOS 7 Apple дает нам возможность решать вопрос масштабирования при помощи нового инструмента — Auto Layout Constraints. Но при загрузке View из кода ей не проставляются никакие констрейнты автоматически.

Выход — добавить констрейнты вручную.

Для этого после загрузки View из Xib напишем следующий код:

//запрещаем трансляцию autoresizing mask в констрейнты (поскольку в xib-е она включена по умолчанию)
viewFromXib.TranslatesAutoresizingMaskIntoConstraints = false;

viewController.View.Add(viewFromXib);

//добавляем констрейнты для авторесайза вьюхи из xib-а после того, как мы эту вьюху добавили в иерархию родителя
NSDictionary viewDict = NSDictionary.FromObjectAndKey(viewFromXib, new NSString("viewFromXib"));
viewController.View.AddConstraints(NSLayoutConstraint.FromVisualFormat(new NSString("H:|[viewFromXib]|"), 0, null, viewDict));
viewController.View.AddConstraints(NSLayoutConstraint.FromVisualFormat(new NSString("V:|[viewFromXib]|"), 0, null, viewDict));

Динамическое изменение лэйаута для прортретной и ландшафтной ориентации на iPad

Mon, 23 Nov 2015 21:59:09 +0300

Хороший интерфейс пользователя должен быть адаптивным и изменяться в зависимости от размера и соотношения сторон экрана. Всем известно, что компания Apple обладает своим собственным подходом к построению интерфейса. В отличии от Android, для того чтобы нарисовать интерфейс для iOS не достаточно описать его с помощью декларативного языка. На iOS придется работать в Interface Builder, рисовать контролы ручками и описывать их взаимоотношения при помощи “ограничений” (Auto Layout Constraints).

Точно так же Apple обладает своим собственным видением того, как реагировать на изменение размера и соотношений сторон экрана. Для того, чтобы правильно отображать интерфейс для различных экранов Apple предлагает разработчику инструмент под названием Size Classes. Если кратко — то всего существует 2 сайз класса (один для горизонтали, второй для вертикали), каждый из которых может иметь одно из двух значений (Regular — обычный и Compact — компактный). При этом в зависимости от типа устройства и его ориентации эти сайз классы изменяют свои значения.

Например для iPhone 5 в портретной ориентации горизонтальный сайз класс будет иметь значение Compact, а вертикальный — Regular. Если iPhone развернуть в ландшафт — то сайз классы поменяются местами (горизонталь станет Regular, вертикаль — Compact).

Таким образом начиная с iOS 7 на Size classes завязано все изменение лэйаутов в Interface Builder. При этом нельзя нарисовать два лэйаута для разных наборов сайз классов — нам необходимо включать или выключать констрейнты (Auto Layout Constraints) в зависимости от значения сайз класса. Уже на устройстве система сама поймет какие сайз классы в данный момент активны и автоматически отключит или включит соответствующие констрейнты, интерфейс будет выглядеть по разному в ландшафте или портрете.

В случае iPad картина выглядит иначе. Планшет обладает одинаковым значением сайз классов для горизонтали и вертикали в любой ориентации. Такое поведение системы добавляет некоторые сложности, когда нам нужно для портрета и ландшафта иметь различные лэйауты, например так:

Но существует способ обойти такое поведение системы, для этого необходимо выполнить следующее:

Добавить отдельные констрейнты для ландшафта и портрета
Вывести две IBOutlet Collection (одну для портрета, вторую для ландшафта) и привязать соответствующие констрейнты к соответствующему аутлету
В коде подписаться обзервером на событие UIDeviceOrientationDidChangeNotification. По событию проверять идиому интерфейса пользователя и по ориентации статус бара понимать как развернуто устройство, и активировать соответствующий набор констрейнтов

Пройдемся краткой по основным этапам.

Добавить отдельные констрейнты для ландшафта и портрета

Чтобы правильно добавить необходимые констрейнты необходимо действовать в следующем порядке:

1. Для начала нарисовать лэйаут под портретную ориентацию
2. Понять какие констрейнты будут общими, а какие будут относиться только к портрету
3. Для каждого не общего констрейнта добавить его вариант для любой ширины и Regular высоты (Any Width & Regular Height)

4. Далее выключить этот констрейнт в версии без указания сайз классов
5. Повторить пункты 3 и 4 для всех констрейнтов, которые будут уникальными для портретной ориентации
6. Теперь необходимо на том же экране добавить констрейнты для ландшафтной ориентации
7. Для всех констрейнтов, уникальных для ландшафтной ориентации добавить их варианты для любой ширины и компактной высоты (Any Width & Compact Height)
8. Далее выключить этот констрейнт в версии без указания сайз классов
9. Повторить пункты 7 и 8 для всех констрейнтов, которые будут уникальными для ландшафтной ориентации

Вывести две IBOutlet Collection (одну для портрета, вторую для ландшафта) и привязать соответствующие констрейнты к соответствующему аутлету

Например начнем с портретных констрейнтов, откроем Assistant Editor, найдем в левом пане наш констрейнт (он сейчас должен быть выключен) и перетянем его (с зажатым Ctrl) в пан с кодом (Assistant Editor)

В окне задания свойств аутлета необходимо ввести его имя и обязательно выбрать в поле Connection значение Outlet Collection.

Далее нажать Connect — наш новый аутлет свяжется с констрейнтом. Далее необходимо осуществить хитрость — не достаточно просто повторить предыдущие шаги с оставшимися констрейнтами для портретной ориентации. Оставшиеся коснтрейнты необходимо соединять с нашим аутлетом через окно инспектора соединений (Connections Inspector). Для этого необходимо выделить констрейнт, открыть его инспектор соединений и из поля Referencing Outlet Collections вытянуть соединение с нашим аутлетом.

На этом работа в Interface Builder закончена.

В коде подписаться обзервером на событие “UIDeviceOrientationDidChangeNotification”

В коде нашего контроллера в методе viewDidLoad необходимо подписаться на событие обзервера UIDeviceOrientationDidChangeNotification. Оно будет вызываться всякий раз, когда ориентация устройства изменяется.

NSNotificationCenter.DefaultCenter.AddObserver(new NSString("UIDeviceOrientationDidChangeNotification"), (notification) =>
{
	UpdateControlsFrames();
});

Далее необходимо реализовать метод UpdateControlsFrames() и внутри него по идиоме интерфейса и положению статус бара активировать констрейнты либо портрета, либо ландшафта.

void UpdateControlsFrames()
{
	if ((new UIDevice()).UserInterfaceIdiom != UIUserInterfaceIdiom.Pad)
	{
		return;
	}

	bool isPortraint = true;
	if (UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.LandscapeLeft
		|| UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.LandscapeRight)
	{
		isPortraint = false;
	}

	if (isPortraint)
	{
		NSLayoutConstraint.DeactivateConstraints(landscapeLayoutConstraints);
		NSLayoutConstraint.ActivateConstraints(portraintLayoutConstraints);
	}
	else
	{
		NSLayoutConstraint.DeactivateConstraints(portraintLayoutConstraints);
		NSLayoutConstraint.ActivateConstraints(landscapeLayoutConstraints);
	}

	View.SetNeedsLayout();
	View.LayoutSubviews();
}

Стоит сказать о том, что после активации констрейнтов необходимо вызвать SetNeedsLayout() и LayoutSubviews() у корневой View, чтобы она перерисовалась с учетом последних изменений.

Использование Fragment без UI для хранения данных

Fri, 19 Jun 2015 21:01:03 +0300

Fragment — это сущность, позволяющая инкапсулировать часть интерфейса и его логику для переиспользования. Фрагменты были представлены в Android 3.0 и позволили существенно упростить работу по проектированию интерфейса для устройств с различными размерами экранов (так называемая парадигма Responsive Design, когда одно и то же приложение выглядит по разному на устройствах с различной диагональю экрана).

Фрагменты очень удобны и обладают следующими основными свойствами:

Очень похожи на Activity и имеют схожий цикл жизни, при этом дополненный несколькими событиями;
Как и Activity инкапсулируют логику работы с интерфейсом;
Могут жить только внутри Activity, при этом один и тот же фрагмент может быть использован в различных Activity, что существенно упрощает задачу при проектировании интерфейса для различных устройств.

Фрагменты обладают ещё одним свойством, которое может быть весьма полезно при разработке приложений — фрагмент можно создать вовсе без пользовательского интерфейса и заставить его не умирать при пересоздании родительской Activity. Это свойство может быть очень к месту для хранения источника данных (модели) в таком фрагменте.

Для многих начинающих разработчиков, пришедших с десктопных платформ, может стать настоящим откровением поведение Android например при изменении ориентации устройства — в таком случае Activity будет уничтожена и создана вновь с лэндскейпным лэйаутом. Соответственно если к Activity привязан какой-либо источник данных — он будет так же пересоздан (или перезагружен, в случае ContentProvider).

Чтобы этого не произошло можно создать специальный фрагмент без UI и передать в его конструкторе значение true в сеттер setRetainInstance (Java), либо установить значение true свойству RetainInstance (C#). Далее инициализировать и сохранить в нём нашу модель.

Все, после подобных манипуляций получим постоянный доступ к модели с сохранением её состояния даже при пересоздании родительской Activity.

Ниже небольшой пример кода на C# и Xamarin:

/// <summary>
/// Фрагмент без интерфейса, будет хранить нашу модель
/// (данный фрагмент будет ретейниться после уничтожения основной вьюхи и наши данные не будут перегенериваться при пересоздании Activity)
/// </summary>
public class ModelHolderFragment : Android.App.Fragment{
	public static string SearchTag = "MODEL_HOLDER_FRAGMENT";

	public ViewPagerItem[] DataSourceItems { get; private set;}

	public override void OnCreate (Bundle savedInstanceState)
	{
		base.OnCreate (savedInstanceState);

		DataSourceItems = GenViewPagerItems ();

		//установим флаг, который запретит фрагменту умирать при уничтожении основной вьюхи
		RetainInstance = true;
	}

	/// <summary>
	/// Генерация фейковых данных
	/// </summary>
	/// <returns>The view pager items.</returns>
	private ViewPagerItem[] GenViewPagerItems(){
		...
		return items;
	}
}

///Хэндлер события OnCreate родительской Activity - тут создадим экземпляр нашего фрагмента
protected override void OnCreate(Bundle savedInstanceState) {
	base.OnCreate(savedInstanceState);
	SetContentView (Resource.Layout.activity_main);

	//инициализируем фрагмент без интерфейса для хранения модели только при первом создании вьюхи
	if (savedInstanceState == null) {
		FragmentManager.BeginTransaction ().Add ((Android.App.Fragment)new ModelHolderFragment (), ModelHolderFragment.SearchTag).Commit();
		FragmentManager.ExecutePendingTransactions ();
	}
	_model = (ModelHolderFragment)FragmentManager.FindFragmentByTag (ModelHolderFragment.SearchTag);
}

Использование паттерна ViewHolder

Wed, 17 Jun 2015 10:56:43 +0300

С этой статьи я бы хотел начать цикл кратких заметок о разработке под мобильные устройства. Приложения под телефоны и планшеты — мое давнее увлечение. К сожалению плотно заняться которым, в силу различных обстоятельств, я смог только сейчас. В прочем хватит лирики, начнём. В качестве платформы я выбрал Android, как наиболее массовую и открытую систему. В качестве языка программирования сегодня будем использовать C#, писать будем на Xamarin с использованием Android API.

Практически любое мобильное приложение это некий экран с набором однотипных информационных элементов, для отображения которых обычно используется список или какой-либо грид. Из-за того, что платформа мобильная и работает на устройстве с небольшим объёмом памяти и слабым процессором (хаха! В моем первом компьютере было памяти раз в 15 меньше и процессор существенно слабее, чем сейчас в среднем телефоне) операционная система вынуждена ресурсы экономить. Соответственно если речь идёт о списке (ListView в Android), а если точнее об адаптере, который предоставляет данные для списка (например ArrayAdapter в Android) мы сталкиваемся с одной из особенностей, вызванных необходимостью беречь ресурсы.

Такая особенность заключается в том, что лист не создаёт ячейки под каждую из записей подключенного источника данных. Он создаёт лишь то количество ячеек, сколько может уместиться на экране в данный момент плюс по одной лишней ячейке сверху и снизу. Такое поведение характерно не только для Android, но и для iOS.

При этом когда пользователь прокручивает список система не удаляет ячейки, она старается их переиспользовать.

Когда ячейка пропадает из поля видимости пользователя она передаётся в метод GetView() адаптера, в котором происходит заполнение ячейки данными. В этом методе можно решить, переиспользовать уже готовую ячейку или создать новую.

Все бы ничего, но если лэйаут ячейки сложный то мы напрямую сталкиваемся с необходимостью проводить поиск элементов в лэйауте (TextView, ImageView и т. п.) для заполнения их актуальными данными. Вроде бы ничего страшного, вызвал FindViewById() с нужным id элемента, получил его и нет проблем, но выполнение метода FindViewById() это длительная операция, потому что она тянет за собой траверс по XML-коду лэйаута нашей ячейки. В итоге на сложных лэйаутах имеем просадку по производительности скроллинга списка.

Чтобы решить данную проблему нам необходимо использовать паттерн ViewHolder. Кратко его суть заключается в следующем:

Реализуем класс, который в конструкторе принимает нашу View, делает траверс и ищет все её элементы, которые нам потребуются для заполнения данных;
Записываем ссылки на эти элементы в соответствующие поля класса, снабжаем их геттерами, чтобы потом к ним обращаться;
При создании нашей View — создаём наш класс-ViewHolder и записываем ссылку на него в свойстве Tag у нашей View;
Теперь при попытке переиспользовать View нам не нужно делать повторный поиск элементов в лэйауте, достаточно получить ссылку на ViewHolder из свойства Tag и обратиться к соответствующим геттерам холдера;
PROFIT.

Если делать реализацию на Java сложностей возникнуть не должно, но если использовать C# и Xamarin мы столкнемся с корнями, растущими из Java :-)

Предположим есть такой класс:

public class MyViewHolder{
public TextView MyTextView {get; private set;}

public MyViewHolder(View view){
...
}
}

Если теперь попытаться присвоить ссылку на него свойству Tag нашей View у нас ничего не получится. Поскольку Tag принимает объект типа Java.Lang.Object, а наш класс наследован от типа Object. Прямое кастование к нужному типу так же не приведёт к успеху. Кастование сначала к Object, а потом к Java.Lang.Object не даст ошибки компиляции, зато упадёт в рантайме.

Что же делать? Все просто :-) наследовать наш класс от типа Java.Lang.Object и будет счастье!

Небольшой пример того, как все это работает:

public class TimetableItemAdapter : ArrayAdapter<TimetableItem>
{
	/// <summary>
	/// Класс ViewHolder, нужен что бы исключить множественный траверс по элементам вьюхи, для производительности
	/// </summary>
	public class TimetableItemViewHolder : Java.Lang.Object{
		public TextView TimeText { get; private set;}
		public TextView DescriptionText { get; private set;}
		public ImageView AcceptButton { get; private set;}

		public TimetableItem BoundedItem { get; set;}

		public TimetableItemViewHolder(View view, TimetableItem item){
			TimeText = view.FindViewById<TextView>(Resource.Id.timetable_time_text);
			DescriptionText = view.FindViewById<TextView>(Resource.Id.timetable_description_text);
			AcceptButton = view.FindViewById<ImageView>(Resource.Id.timetable_accept);

			BoundedItem = item;
		}
	}

	private MainActivity _context;

	public TimetableItemAdapter(Context context, int resource, IList<TimetableItem> objects) : base(context, resource, objects) {
		_context = (MainActivity)context;
	}
			
	public override View GetView(int position, View convertView, ViewGroup parent) {
		View resultView = null;
		TimetableItemViewHolder holder = null;
		TimetableItem item = GetItem(position);

		if(convertView != null){
			resultView = convertView;
			holder = (TimetableItemViewHolder)convertView.Tag;
			holder.BoundedItem = item;
		}else{
			resultView = ((LayoutInflater)_context.GetSystemService(Context.LayoutInflaterService))
				.Inflate(Resource.Layout.timetable_list_item, parent, false);
			holder = new TimetableItemViewHolder(resultView, item);
			resultView.Tag = holder;
		}

		if(item != null && holder != null){
			holder.TimeText.Text = item.Time;
			holder.DescriptionText.Text = item.Description;
		}

		return resultView;
	}
}

Во ViewHolder не обязательно хранить только ссылки на элементы лэйаута, иногда может потребоваться хранить и какие-либо сопутствующие данные. Например в коде выше во ViewHolder записывается дополнительно ссылка на элемент из источника данных, для последующего использования где-нибудь. Но в данном случае нужно помнить, что при переиспользовании View нужно не забыть записать в свойство ссылку на новый элемент источника данных.