Parse – облачная служба для Android-приложений

Хранение в облаке и извлечение учетных записей пользователей, объектов данных и файлов Android-приложения

Читатель узнает о преимуществах хранения данных мобильных приложений в частном облаке с помощью SDK для Android. Специалист по мобильным технологиям К.Энрике Ортис рассказывает о классах API Parse для хранения данных в облаке и манипулирования учетными записями пользователей, объектами данных и файлов мобильных приложений.

Мобильный SDK Parse предоставляет API и службы на основе облака для приложений на платформах iOS, Android и Windows®. Кроме того, SDK Parse обеспечивает API JavaScript и REST. С помощью API Parse можно очень быстро и с минимальными усилиями делать мобильные приложения "облачными". Мобильное приложение, интегрированное с API Parse, может хранить объекты данных и файлы на облаке Parse, отправлять и принимать уведомления, управлять пользователями, обрабатывать данные о местоположении и работать с платформами социальных сетей, такими как Twitter и Facebook. Когда мобильное приложение нужно масштабировать, SDK Parse обеспечивает полную эластичность облачной платформы.

Предварительные замечания

Я предполагаю, что читатель уже знаком с основами программирования мобильных приложений с помощью JSON, Android и Eclipse. Прежде чем читать дальше, зайдите на Parse.com и определите свое приложение. Следуйте простым инструкциям, начиная от страницы регистрации.

Эта статья знакомит читателя с основными классами пользователей, объектов данных и файлов API Parse. Он узнает, как работать со списками управления доступом (ACL), как выполнять операции CRUD над объектами данных и как сохранять файлы в облаке Parse и извлекать их. Примеры строятся на SDK Parse для Android (см. раздел Ресурсы).

Информационная панель Parse

Информационная панель Parse помогает разработчикам управлять приложениями. Она содержит общие и специальные параметры использования API и файлов, а также параметры уведомлений. Через эту панель осуществляется управление ключами и параметрами настройки приложений. Кроме того, панель отображает обозреватель данных, в котором разработчики могут просматривать и даже редактировать объекты, хранящиеся в облаке Parse. Обозреватель данных очень полезен для целей отладки. На рисунке 1 представлен скриншот информационной панели Parse.

Рисунок 1. Информационная панель Parse
Скриншот информационной панели Parse.

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

Объекты данных Parse

В Parse данные представляются с помощью контейнера ParseObject, содержащего пару имя-значение. В ParseObject можно хранить любые JSON-совместимые данные, как показано в листинге 1.

Листинг 1. Пример ParseObject
ParseObject myParseObject = new ParseObject("MyObject"); // Имя класса
myParseObject.put("name", "C. Enrique Ortiz");
myParseObject.put("twitterHandle", "eortiz");
myParseObject.put("followers", 123456);

При создании экземпляра ParseObject получает имя класса classname. В листинге 1 classname — это MyObject. Имена классов аналогичны именам таблиц в реляционной базе данных, а объекты Parse из одного и того же класса ― строкам таблицы.

ParseObject предоставляет методы, аналогичные Java-классу Map, такие как put, get и remove, а также ряд других методов, специфичных для ParseObject.

Ключи имениParseObject должны быть алфавитно-цифровыми; используйте для них "горбатый регистр". Значения могут быть данными любого типа, которые можно хранить в JSON: числа, строки, логические значения, массивы, значения JSONObject.NULL, объекты JSONObject и массивы JSONArray. Другие типы данных, поддерживаемых ParseObjectDate Java и массивы byte[]. Объект ParseObject может содержать и другие объекты ParseObject.

В листинге 2 показаны некоторые поддерживаемые ParseObject типы данных.

Листинг 2. ParseObject: некоторые поддерживаемые типы данных
// Байт-массив
byte[] byteArray = {1, 2, 3, 4, 5};

// Дата
Date d = new Date(); // java.util.Date

// Число
int number = 21;

// Строка
String name = "Enrique";

// JSONArray - любое сочетание объектов JSONObject, JSONArray, строк, логических 
// значений, целых чисел, длинных целых чисел, чисел двойной длины и значений null 
// или NULL.
JSONArray jArray = new JSONArray();
jArray.put(number);
jArray.put(name);

// JSONObject 
JSONObject jObject = new JSONObject();
try {
    jObject.put("number", number);
    jObject.put("name", name);
} catch (JSONException e) {
    e.printStackTrace();
}

// ParseObject
ParseObject pObject = new ParseObject("MyObject"); // Имя класса
pObject.put("myByteArray", byteArray);
pObject.put("myDate", d);
pObject.put("myString", name);
pObject.put("myNumber", number);
pObject.put("myJsonArray", jArray);
pObject.put("myJsonObject", jObject);
pObject.put("myNull", JSONObject.NULL);

Код, приведенный в листинге 2, создает ParseObject, который хранится как объект в облаке Parse. Многие объекты MyObject одного и того же класса хранятся как строки объектов данных ParseObject, которые можно сохранять в облачном хранилище Parse, запрашивать, редактировать и удалять. Данные можно сохранить даже тогда, когда приложение находится в автономном режиме — библиотека Parse просто сохранит их локально до восстановления соединения с сетью.

Редактирование ParseObject

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

pObject.remove("myNumber"); // Удаление из pObject поля/ключа myNumber

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

ParseObject: краткое описание

ParseObject ― это объект данных в облаке Parse. Он предоставляет методы для добавления пар имя-значение, проверки наличия данного ключа и удаления или извлечения с сервера заданного объекта ParseObject. Кроме того, ParseObject позволяет использовать различные методы get...() и put...() для манипуляции данными объектов ParseObject, слияния объектов ParseObject, сохранения объектов ParseObject на сервере и т.п.

Пользователи, роли и ACL Parse

Прежде чем я покажу, как выполнять операции CRUD над объектами Parse, читатель должен кое-что узнать о пользователях, ролях и списках управления доступом (ACL) Parse. Все три понятия очень важны для защиты объектов данных приложения.

Пользователи Parse

Класс ParseUser представляет пользователя и обеспечивает функциональность учетной записи пользователя в приложении Parse. С каждым приложением Parse связаны пользователи. ParseUser ― это объект ParseObject, но с дополнительными свойствами имени пользователя, пароля и адреса электронной почты. Можно добавить любые дополнительные данные, которые вы сочтете нужными.

Анонимные пользователи в Parse

Анонимный пользователь в Parse ― это пользователь без имени и пароля. Анонимные пользователи полезны для тех мобильных приложений, которым не требуется проверка подлинности пользователя. Анонимные пользователи могут создавать объекты данных, но такие объекты живут недолго и становятся недоступными после выхода анонимного пользователя.

Пользователи могут зарегистрироваться в приложении Parse, как показано в листинге 3.

Листинг 3. ParseUser — регистрация
ParseUser user = new ParseUser();
user.setUsername("eortiz");
user.setPassword("123456");
user.setEmail("eortiz@nospam.com");
user.put("userType", "Author"); // добавление еще одного поля

// Вызов асинхронного фонового метода регистрации 
user.signUpInBackground(new SignUpCallback() {
  public void done(ParseException e) {
    if (e == null) {
      // Успешно. Доступ к приложению разрешен.
    } else {
      // Отказ…
    }
  }
});

Значения username и email должны быть уникальными. Если имя пользователя или адрес электронной почты уже используется, регистрация завершится отказом. Нужен механизм для уведомления пользователя, если одно из полей не проходит, а также процесс повторной попытки.

После регистрации пользователь может войти в приложение, как показано в листинге 4.

Листинг 4. ParseUser — вход
ParseUser.logInInBackground("eortiz", "123456", new LogInCallback() {
  public void done(ParseUser user, ParseException e) {
    if (user != null) {
      // Успешно. Доступ к приложению разрешен.
    } else {
      // Отказ
    }
  }
});

Сведения о пользователе можно отредактировать, вызвав ParseUser.save(). Заметьте, однако, что только владелец ParseUser может изменять его содержание; для всех остальных это данные только для чтения.

Parse записывает вошедшего в систему пользователя во временную память. Можно запросить имя текущего пользователя, вызвав ParseUser.currentUser(). Метод currentUser позволяет быстро получить сведения о текущем пользователе, так что если текущий пользовательский сеанс не активен, достаточно запросить учетные данные. В листинге 5 показано, как извлечь сведения о текущем пользователе Parse

Листинг 5. ParseUser — получение сведений о текущем пользователе
ParseUser currentUser = ParseUser.getCurrentUser();
if (currentUser != null) {
  // текущий пользователь проверен
} else {
  // текущий пользователь не проверен, запрос учетных данных
}

Сброс текущего пользователя

Можно сбросить текущего пользователя Parse, вызвав ParseUser.logOut(), как показано в листинге 6.

Листинг 6. ParseUser — сброс текущего пользователя (выход)
ParseUser.logOut(); // статический метод

ACL Parse

ACL — это список разрешений доступа (или элементов управления), связанных с объектом данных. Класс ParseACL позволяет определить разрешения для данного объекта ParseObject. С помощью ACL можно определить доступ public к объектам данных своего приложения и ограничить доступ определенными пользователями или группами пользователей (посредством ролей). В листинге 7 приведен пример применения ACL Parse.

Листинг 7. Применение ParseACL для разрешения доступа
// Определение пользователя Parse
ParseUser user = new ParseUser();
user.setUsername(username);
:
:

// Определение ACL для чтения и записи
ParseACL rwACL = new ParseACL();
rwACL.setReadAccess(user, true); // разрешить пользователю чтение
rwACL.setWriteAccess(user, true); // разрешить пользователю запись
:
:

// Определение объекта Parse и его ACL
ParseObject gameObject = new ParseObject("Game");
gameObject.setACL(rwACL); // разрешить пользователю чтение/запись в gameObject
gameObject.saveInBackground(); // Сохранение объекта из ACL в облаке
:
:

// Можно определить общедоступный ACL, который предоставляет доступ public к объекту
ParseACL publicACL = new ParseACL();
publicACL.setPublicReadAccess(true);
publicACL.setPublicWriteAccess(true);      
gameObject.setACL(publicACL); // разрешить чтение/запись public 
gameObject.saveInBackground(); // Сохранение объекта из ACL в облаке

Можно также определить ACL по умолчанию для всех вновь создаваемых объектов. В листинге 8 приведен ACL по умолчанию, который можно сделать общедоступным для операций чтения и записи, как это определено оператором publicACL в листинге 7.

Листинг 8. Установка ACL по умолчанию
// Установка ACL по умолчанию, чтобы делать все вновь создаваемые объекты общедоступными
ParseACL.setDefaultACL(publicACL, true);

Хотя это здесь не показано, можно также использовать класс ParseRole для разрешения доступа группам пользователей.

Теперь посмотрим, как объекты данных Parse сохраняются в облаке Parse и извлекается из него.

Объекты данных Parse в облаке

Когда объекты ParseObject созданы и заполнены, их можно сохранить в облаке Parse. На самом деле сохранение объектов данных в облаке Parse ― одна из самых простых вещей, которые можно делать в Parse; Parse полностью скрывает сложности, связанные с представлением данных, маршалингом, установлением сетевой связи и транспортировкой и т.п. Нужно будет использовать вспомогательные методы для преобразования экземпляров объектов данных в ParseObject и обратно, а также решить, направить ли операцию Parse в свой собственный поток или использовать метод сохранения в фоновом режиме.

Остерегайтесь блокирования системного потока!

Напомним, что в мобильных приложениях длинные операции, такие как операции с сетью, файлами или длинные вычисления, не следует выполнять в основном системном потоке. Их лучше выполнять в отдельном рабочем потоке. Блокирование системного потока негативно скажется на реакции UI приложения и может привести к его принудительному закрытию.

ParseObject предоставляет два вида методов сохранения: save() и saveInBackground(). saveInBackground() - это рекомендуемый метод сохранения, так как он выполняет операцию сохранения в своем собственном рабочем потоке. Если вы решите использовать синхронной метод save(), то имейте в виду, что сами несете ответственность за то, чтобы вызывать этот метод в своем собственном рабочем потоке во избежание блокирования пользовательского интерфейса.

В листинге 9 приведен код сохранения объекта данных Parse в фоновом режиме.

Листинг 9. Сохранение ParseObject в фоновом режиме
// ParseObject
ParseObject pObject = new ParseObject("ExampleObject");
pObject.put("myNumber", number);
pObject.put("myString", name);
pObject.saveInBackground(); // асинхронный, без обратного вызова

В листинге 10 приведен код сохранения объекта данных Parse в фоновом режиме с обратным вызовом.

Листинг 10. Сохранение в фоновом режиме с обратным вызовом
pObject.saveInBackground(new SaveCallback () {
    @Override
    public void done(ParseException ex) {
        if (ex == null) {
            isSaved = true;
        } else {
            // Отказ
            isSaved = false;
        }
    }
  });

Имеются следующие варианты метода save...():

  • saveAllinBackground() сохраняет ParseObject с обратным вызовом или без него;
  • saveAll(List<ParseObject> objects) сохраняет список объектов ParseObjects;
  • saveAllinBackground(List<ParseObject> objects) сохраняет список объектов ParseObjects в фоновом режиме;
  • saveEventually() позволяет сохранить объект данных на сервере в некоторый момент времени в будущем; используйте этот метод, если облако Parse недоступно.

После успешного сохранения ParseObject в облаке ему присваивается уникальный идентификатор объекта. Этот идентификатор очень важен, поскольку он однозначно идентифицирует экземпляр ParseObject. Идентификатор объекта можно использовать, например, для определения того, что объект был успешно сохранен в облаке, для извлечения и обновления экземпляра объекта Parse и для удаления конкретного ParseObject.

Получение объектов данных из облака

В этом разделе рассматриваются методы запроса и извлечения объектов данных, хранящихся в облаке Parse. Можно запросить один ParseObject по object-ID или сделать запрос одного или нескольких объектов Parse с помощью атрибутов. Если ParseObject уже есть, его содержимое можно обновлять или синхронизировать, извлекая последние значения с сервера. Мы рассмотрим все эти варианты в последующих примерах.

Извлечение ParseObjects

Для извлечения объекта данных из облака Parse используйте метод ParseObjectfetch() или fetchInBackground(), как показано в листинге 11.

Листинг 11. Извлечение (безусловное)
// ParseObject
ParseObject pObject = new ParseObject("ExampleObject");
:
:

// Безусловное извлечение ParseObject
try {
    pObject.fetch();
} catch (ParseException e) {
    e.printStackTrace();
}

// Безусловное извлечение ParseObject с помощью Callback
pObject.fetchInBackground(new GetCallback() {
    @Override
    public void done(ParseObject obj, ParseException ex) {
        if (ex == null) {
            // Успешно
        } else {
            // Ошибка
        }            
    }
});

Объект можно извлекать и только в случае необходимости; например получить объект Parse, имеющий зависимые объекты Parse, как показано в листинге 12.

Листинг 12. Извлечение объекта при необходимости
ParseObject po = new ParseObject("ExampleObject");
:

ParseObject po2 = po.getParseObject("key");

// Извлечение только при необходимости
try {
    po2.fetchIfNeeded();
} catch (ParseException e) {
    e.printStackTrace();
}

Другая возможность ― выполнять операцию извлечения при необходимости в фоновом режиме с помощью обратного вызова. Для этого нужно использовать метод объекта Parse fetchIfNeededInBackground(GetCallback callback).

Иногда требуется извлечь сразу целую коллекцию объектов Parse, безусловно или при необходимости. ParseObject предоставляет для этого набор статических методов; каждый из них принимает и возвращает список объектов Parse:

  • fetchAll(List<ParseObject> objects)
  • fetchAllIfNeeded(List<ParseObject> objects)
  • fetchAllIfNeededInBackground(List<ParseObject> objects, FindCallback callback)
  • fetchAllInBackground(List<ParseObject> objects, FindCallback callback)

Поиск объектов данных в облаке

Надеюсь, что вы уже поняли, насколько широки возможности API Parse — но это еще не все! Помимо извлечения объектов данных, Parse позволяет запрашивать объекты данных по object-ID или атрибутам. Для запроса объекта данных из облака Parse используется метод ParseQuery. Его можно использовать как для простых, так и для сложных запросов данных, получая определенный объект или подходящие объекты согласно списку List.

В листинге 13 показано, как извлечь конкретный объект Parse с сервера в фоновом потоке по идентификатору object-ID.

Листинг 13. Использование ParseQuery для получения заданного ParseObject
String myID = "12345";
ParseQuery query = new ParseQuery("Players");
query.getInBackground(myID, new GetCallback() {
    @Override
    public void done(ParseObject object, ParseException e) {
        if (object != null) {
            // Получить объект
        } else {
            // Не найден
        }
    }            
});

Обратите внимание, что query.getInBackground() не использует кэш ParseQuery.

В листинге 14 приведен запрос, который извлекает все объекты данных класса Players. (Без ограничений.)

Листинг 14. Использование ParseQuery для всех объектов ParseObjects заданного класса
ParseQuery query = new ParseQuery("Players");
query.findInBackground(new FindCallback() {
    @Override
    public void done(List<ParseObject> players, ParseException e) {
        if (players != null) {
            // Получение списка игроков
        } else {
            // Игроков нет
        }
    }
});

В листинге 15 я использовал ограничение запроса, чтобы выбрать один или более соответствующих объектов Parse; в данном случае, активных игроков.

Листинг 15. Использование ParseQuery для получения заданных объектов ParseObject


ParseQuery query = new ParseQuery("Players");
query.whereEqualTo("status", "active");
query.findInBackground(new FindCallback() {
    @Override
    public void done(List<ParseObject> players, ParseException e) {
        if (players != null) {
            // Успех – среди игроков есть активные 
        } else {
            // Совпадений нет
        }
    }
});

В ParseQuery имеется также метод для подсчета совпадающих объектов без извлечения самих этих объектов ― это очень полезно. В листинге 16 показано, как подсчитать активных игроков.

Листинг 16. Использование ParseQuery для подсчета нужных объектов ParseObject
ParseQuery query = new ParseQuery("Players");
query.whereEqualTo("status", "active"); //remove this line to count ALL
query.countInBackground(new CountCallback() {
    @Override
    public void done(int count, ParseException e) {
        if (e == null) {
            // Успех, см переменную count
        } else {
            // Совпадений нет
        }
    }
});

Методы и ограничения ParseQuery

ParseQuery поддерживает более 20 различных методов запросов с ограничениями; вот несколько примеров:

  • whereMatches(String key, String regex) находит строковые значения, соответствующие указанному регулярному выражению;
  • whereStartsWith(String key, String prefix) находит строковые значения, начинающиеся с указанной строки;
  • whereContains(String key, String substring) находит строковые значения, содержащие указанную строку;
  • whereGreaterThan(String key, Object value) находит значения, которые больше указанного;
  • whereWithinKilometers(String key, ParseGeoPoint point, double maxDistance) находит объекты со значениями в окрестностях указанного места в пределах заданного максимального расстояния.

Результаты запроса можно упорядочить, как показано в листинге 17. Для этого вызовите один из методов query orderBy...(), указав поле сортировки.

Листинг 17. Упорядочение результатов запроса
query.orderByAscending("name"); 

query.orderByDescending("name");
For example:
ParseQuery query = new ParseQuery("Players");
query.whereEqualTo("status", "active");
query.orderByAscending("lastName"); // По фамилии в возрастающем порядке
query.findInBackground(new FindCallback() {
    @Override

  public void done(List<ParseObject> players, ParseException e) {

    if (players != null) {
      // Успех – среди игроков есть активные

    } else {

      // Совпадений нет

                          } 

             }	

});

Еще нужно отметить, что результаты ParseQuery кэшируются. Можно задать политику кэширования запросов различными способами в зависимости от требований приложения. В настоящее время поддерживаются следующие политики кэширования:

  • IGNORE_CACHE: не использовать кэш; это политика кэширования по умолчанию;
  • CACHE_ONLY: загрузка только из кэша. Если в кэше результатов нет, выдается ParseException;
  • NETWORK_ONLY: всегда обращаться в сеть, но сохранять результаты в кэше;
  • CACHE_ELSE_NETWORK: в первую очередь обращаться в кэш. Если данных нет, они загружаются из сети. Если там совпадений тоже нет, результатом будет ParseException;
  • NETWORK_ELSE_CACHE: в первую очередь обращаться в сеть. Если это не удается, данные загружаются из кэша. Если там совпадений тоже нет, результатом будет ParseException;
  • CACHE_THEN_NETWORK: в первую очередь обращаться в кэш, а затем загружать данные из сети. Обратите внимание, что FindCallback на самом деле вызывается дважды: сначала для результатов из кэша, затем из сети. Эту политику можно использовать только асинхронно с методом findInBackground.

Задать политику кэша легко. Это делается перед вызовом метода find...(), как показано в листинге 18.

Листинг 18. Управление CachePolicy
ParseQuery query = new ParseQuery("Players");
query.setCachePolicy(ParseQuery.CachePolicy.NETWORK_ELSE_CACHE);
query.findInBackground(new FindCallback() {
    @Override
    public void done(List<ParseObject> players, ParseException e) {
        if (e == null) {
            // Успех – среди игроков есть активные 
        } else {
            // Совпадений нет
        }
    }
});

Класс ParseQuery предоставляет методы, необходимые для выполнения запросов объектов данных, хранящихся в облаке. С помощью метода ParseQuery можно указать ограничения запросов всех видов, подсчитать совпадения объектов данных, установить ограничения, пропустить объекты данных, отсортировать их, очистить кэш и многое другое.


Удаление объектов данных

Операция удаления объекта данных из облака Parse также очень проста. Когда есть экземпляр объекта, можно удалить существующий ParseObject из облака, вызвав метод ParseObjectdelete() или deleteInBackground(). Оба показаны в листинге 19.

Листинг 19. Удаление объекта Parse из облака
parseObject.delete();
parseObject.deleteInBackground();

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

Работа с файлами

До сих пор мы работали с объектами Parse и запросами Parse. Я также познакомил читателя с пользователями, ACL и ролями Parse. В заключении я продемонстрирую работу с файлами - чтение, запись и сохранение функций в Parse.

Напомню, что неструктурированные данные byte[] можно хранить внутри ParseObject, что очень удобно для небольшого количества данных. При хранении более крупных элементов, таких как изображения или документы, используйте Parse Files.

Файлы в облаке Parse отображаются с помощью класса ParseFile, который предоставляет методы для получения имени файла, его URL и данных из этого файла, если они есть. Можно также загружать и передавать файлы и обращаться к некоторым другим вспомогательные методам.

Данные файлов представляются с помощью синтаксиса byte[]. Обратите внимание, что в настоящее время размер файла не может превышать 10 МБ. При вводе имени файла библиотека Parse заботится о возможных конфликтах имен. Указание расширения файла помогает Parse обрабатывать его содержимое.

Листинг 20 демонстрирует сохранение файла JPG.

Листинг 20. Сохранение ParseFile
// Сохранение файла изображения
Drawable drawable = ...;
Bitmap bitmap = (Bitmap)((BitmapDrawable) drawable).getBitmap();
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
byte[] data = stream.toByteArray();                
ParseFile imageFile = new ParseFile("image.jpg", data);
imageFile.saveInBackground();

Первые операторы в листинге 20 преобразуют растровое изображение в byte[]. Затем byte[] сохраняется с помощью метода ParseFile saveInBackground(), подобно тому, как ParseObject сохраняется на сервере.

Когда файл сохранен в Parse, его нужно связать (put into) с ParseOject. Другими словами, файлы Parse не являются истинными автономными объектами, и чтобы извлечь их и использовать позже, их нужно связать с данным экземпляром ParseObject. В будущей версии Parse это ограничение, возможно, будет устранено. В листинге 21 файл изображения связывается с объектом Parse Player.

Листинг 21. Связывание ParseFile с ParseObject
// Изображение ставится в соответствие объекту Parse
ParseObject po = new ParseObject("Players");
po.put("name", "eortiz");
po.put("photo", imageFile);
po.saveInBackground();

Я связал этот файл с объектом данных, а затем сохранил объект на сервере с помощью метода saveInBackgroud(), о котором говорилось выше.

В листинге 22 показано, как извлечь файл, связанный с объектом данных.

Листинг 22. Извлечение ParseFile
// Извлечение файла 
ParseFile imageFile2 = (ParseFile)po.get("photo");
imageFile2.getDataInBackground(new GetDataCallback() {
  public void done(byte[] data, ParseException e) {
    if (data != null) {
      // Успешно; файл имеется в данных
    } else {
      // Совпадений нет
    }
  }
});

Получив ссылку ParseFile из объекта Parse, я вызвал getDataInBackground(), чтобы извлечь ParseFile с сервера. Обратите внимание, что для извлечения файлов Parse я использовал обратный вызов GetDataCallback, вместо GetCallback, который предназначен для извлечения объектов Parse с помощью ParseQuery.

Заключение

API Parse всеобъемлющ и содержит классы для доступа к мобильным сервисам, таким как уведомления, использование географических данных, интеграция с платформами социальных сетей и многое другое. В этой статье я лишь коснулся того, что можно делать с помощью Parse, представив API Parse для хранения данных и файлов в облаке. Умение хранить и манипулировать учетными записями пользователей, объектами данных, файлами и списками ACL в облаке Parse служит хорошей основой для дальнейшего изучения этой облачной платформы разработки мобильных приложений.

Ресурсы

  • Оригинал статьи: Parse cloud-based services for Android apps.
  • Подробнее о Parse Android SDK; см. также Краткое руководство по Parse (EN), чтобы выбрать мобильную платформу, настроить приложение и загрузить и установить SDK Parse.
  • Полный список API Parse для Android.
  • Develop Android applications with Eclipse (Frank Ableson, developerWorks, февраль 2008 г.): практика разработки Android-приложений в среде Eclipse, на этот раз с помощью плагина Android Eclipse.
  • Introduction to jQuery Mobile (C. Enrique Ortiz, developerWorks, май 2012 г.): основы jQuery Mobile и разработки интерфейса пользователя мобильных Web-приложений. Примеры страниц, элементов навигации, панелей инструментов, списков, форм и переходных эффектов в jQuery Mobile.
  • Solve your many-device-to-many-platform mobile application integration challenges (Olivier Picciotto, developerWorks, август 2012 г.): сегодня разработка мобильных приложений и облачные вычисления практически неразделимы, но интеграция мобильных приложений в облако — все еще неизведанная территория. Это статья о том, как платформа мобильных приложений предприятия (MEAP) решает некоторые проблемы интеграции мобильных приложений и облака.
  • DevOps for mobile development» (Майкл Роу, developerWorks, июль 2012 г.): компании во всем мире желают эксплуатировать рынок мобильных устройств, предоставляя клиентам и пользователям приложения, облегчающие мобильные вычисления. В этой статье рассматриваются некоторые технические и экономические вопросы, связанные с интеграцией разработки и эксплуатацией мобильных платформ на рабочих местах.
  • Следите за новостями developerWorks в Twitter.

Комментарии

developerWorks: Войти

Обязательные поля отмечены звездочкой (*).


Нужен IBM ID?
Забыли Ваш IBM ID?


Забыли Ваш пароль?
Изменить пароль

Нажимая Отправить, Вы принимаете Условия использования developerWorks.

 


Профиль создается, когда вы первый раз заходите в developerWorks. Информация в вашем профиле (имя, страна / регион, название компании) отображается для всех пользователей и будет сопровождать любой опубликованный вами контент пока вы специально не укажите скрыть название вашей компании. Вы можете обновить ваш IBM аккаунт в любое время.

Вся введенная информация защищена.

Выберите имя, которое будет отображаться на экране



При первом входе в developerWorks для Вас будет создан профиль и Вам нужно будет выбрать Отображаемое имя. Оно будет выводиться рядом с контентом, опубликованным Вами в developerWorks.

Отображаемое имя должно иметь длину от 3 символов до 31 символа. Ваше Имя в системе должно быть уникальным. В качестве имени по соображениям приватности нельзя использовать контактный e-mail.

Обязательные поля отмечены звездочкой (*).

(Отображаемое имя должно иметь длину от 3 символов до 31 символа.)

Нажимая Отправить, Вы принимаете Условия использования developerWorks.

 


Вся введенная информация защищена.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=40
Zone=Технология Java, Мобильные приложения, Облачные вычисления
ArticleID=932158
ArticleTitle=Parse – облачная служба для Android-приложений
publish-date=05312013