text:
<!DOCTYPE html>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="viewport" content="width=device-width" />

<link rel="shortcut icon" type="image/x-icon" href="../../favicon.ico" />
<title>APK Expansion Files | Android Developers</title>

<link rel="stylesheet"
href="http://fonts.googleapis.com/css?family=Roboto:regular,medium,thin,italic,mediumitalic,bold" title="roboto">
<link href="../../assets/css/default.css" rel="stylesheet" type="text/css">

          	Quicknav
			      Quicknav

                  Design

Develop

Distribute

Links

Google Play Developer Console

Android Developers Blog

About Android

Android Sites

Android.com

Android Developers

Android Open Source Project

      <form onsubmit="return submit_search()">
        <input id="search_autocomplete" type="text" value="" autocomplete="off" name="q"
onfocus="search_focus_changed(this, true)" onblur="search_focus_changed(this, false)"
onkeydown="return search_changed(event, true, '../../')"
onkeyup="return search_changed(event, false, '../../')" />
      </form>

        close

Get Started

Style

Patterns

Building Blocks

Downloads

Videos

Training

API Guides

Reference

Tools

Get the SDK

Google Services

Google Play

Publishing

Promoting

App Quality

Spotlight

Open Distribution

Results

Loading...

Training

API Guides

Reference

Tools

Google Services

to top

          Overview

          Games

          Location

          Google+

          Maps

      Ads

          Advertising ID

          Wallet

          Authorization

      Google Play Services

          Setup

            Reference

      Google Play In-app Billing

              Overview

              Version 3 API

              Implementing the API

              Reference

              Version 2 API

              Implementing the API

              Subscriptions

              Reference

              Subscriptions

              Security and Design

              Testing In-app Billing

              Administering In-app Billing

              Purchase Status API

              Version Notes

        Google Cloud Messaging

            Getting Started

            Architectural Overview

              Cloud Connection Server

              User Notifications

            GCM Client

            GCM Server

            Advanced Topics

            Migration

              Reference

      Google Play Distribution

          Filters on Google Play

          Multiple APK Support

          APK Expansion Files

          Application Licensing

              Licensing Overview

              Setting Up for Licensing

              Adding Licensing to Your App

              Licensing Reference

      Android Backup Service

          Register

APK Expansion Files

Quickview

Recommended for most apps that exceed the 50MB APK limit

You can provide up to 4GB of additional data for each APK

Google Play hosts and serves the expansion files at no charge

The files can be any file type you want and are saved to the device's shared storage

In this document

Overview

File name format

Storage location

Download process

Development checklist

Rules and Limitations

Downloading the Expansion Files

About the Downloader Library

Preparing to use the Downloader Library

Declaring user permissions

Implementing the downloader service

Implementing the alarm receiver

Starting the download

Receiving download progress

Using APKExpansionPolicy

Reading the Expansion File

Getting the file names

Using the APK Expansion Zip Library

Testing Your Expansion Files

Testing file reads

Testing file downloads

Updating Your Application

See also

Application Licensing

Multiple
APK Support

Google Play currently requires that your APK file be no more than 50MB. For most
applications, this is plenty of space for all the application's code and assets.
However, some apps need more space for high-fidelity graphics, media files, or other large assets.
Previously, if your app exceeded 50MB, you had to host and download the additional resources
yourself when the user opens the app. Hosting and serving the extra files can be costly, and the
user experience is often less than ideal. To make this process easier for you and more pleasant
for users, Google Play allows you to attach two large expansion files that supplement your
APK.

Google Play hosts the expansion files for your application and serves them to the device at
no cost to you. The expansion files are saved to the device's shared storage location (the
SD card or USB-mountable partition; also known as the "external" storage) where your app can access
them. On most devices, Google Play downloads the expansion file(s) at the same time it
downloads the APK, so your application has everything it needs when the user opens it for the
first time. In some cases, however, your application must download the files from Google Play
when your application starts.

Overview

Each time you upload an APK using the Google Play Developer Console, you have the option to
add one or two expansion files to the APK. Each file can be up to 2GB and it can be any format you
choose, but we recommend you use a compressed file to conserve bandwidth during the download.
Conceptually, each expansion file plays a different role:

The main expansion file is the
primary expansion file for additional resources required by your application.

The patch expansion file is optional and intended for small updates to the
main expansion file.

While you can use the two expansion files any way you wish, we recommend that the main
expansion file deliver the primary assets and should rarely if ever updated; the patch expansion
file should be smaller and serve as a "patch carrier," getting updated with each major
release or as necessary.

However, even if your application update requires only a new patch expansion file, you still must
upload a new APK with an updated versionCode in the manifest. (The
Developer Console does not allow you to upload an expansion file to an existing APK.)

Note: The patch expansion file is semantically the same as the
main expansion file—you can use each file any way you want. The system does
not use the patch expansion file to perform patching for your app. You must perform patching
yourself or be able to distinguish between the two files.

File name format

Each expansion file you upload can be any format you choose (ZIP, PDF, MP4, etc.). You can also
use the JOBB tool to encapsulate and encrypt a set
of resource files and subsequent patches for that set. Regardless of the file type, Google Play
considers them opaque binary blobs and renames the files using the following scheme:

[main|patch].<expansion-version>.<package-name>.obb

There are three components to this scheme:

main or patch

Specifies whether the file is the main or patch expansion file. There can be
only one main file and one patch file for each APK.

<expansion-version>

This is an integer that matches the version code of the APK with which the expansion is
first associated (it matches the application's android:versionCode
value).

"First" is emphasized because although the Developer Console allows you to
re-use an uploaded expansion file with a new APK, the expansion file's name does not change—it
retains the version applied to it when you first uploaded the file.

<package-name>

Your application's Java-style package name.

For example, suppose your APK version is 314159 and your package name is com.example.app. If you
upload a main expansion file, the file is renamed to:

main.314159.com.example.app.obb

Storage location

When Google Play downloads your expansion files to a device, it saves them to the system's
shared storage location. To ensure proper behavior, you must not delete, move, or rename the
expansion files. In the event that your application must perform the download from Google Play
itself, you must save the files to the exact same location.

The specific location for your expansion files is:

<shared-storage>/Android/obb/<package-name>/

<shared-storage> is the path to the shared storage space, available from
getExternalStorageDirectory().

<package-name> is your application's Java-style package name, available
from getPackageName().

For each application, there are never more than two expansion files in this directory.
One is the main expansion file and the other is the patch expansion file (if necessary). Previous
versions are overwritten when you update your application with new expansion files.

If you must unpack the contents of your expansion files, do not delete the
.obb expansion files afterwards and do not save the unpacked data
in the same directory. You should save your unpacked files in the directory
specified by getExternalFilesDir(). However,
if possible, it's best if you use an expansion file format that allows you to read directly from
the file instead of requiring you to unpack the data. For example, we've provided a library
project called the APK Expansion Zip Library that reads your data directly
from the ZIP file.

Note: Unlike APK files, any files saved on the shared storage can
be read by the user and other applications.

Tip: If you're packaging media files into a ZIP, you can use media
playback calls on the files with offset and length controls (such as MediaPlayer.setDataSource() and
SoundPool.load()) without the
need to unpack your ZIP. In order for this to work, you must not perform additional compression on
the media files when creating the ZIP packages. For example, when using the zip tool,
you should use the -n option to specify the file suffixes that should not be
compressed:

zip -n .mp4;.ogg main_expansion media_files

Download process

Most of the time, Google Play downloads and saves your expansion files at the same time it
downloads the APK to the device. However, in some cases Google Play
cannot download the expansion files or the user might have deleted previously downloaded expansion
files. To handle these situations, your app must be able to download the files
itself when the main activity starts, using a URL provided by Google Play.

The download process from a high level looks like this:

User selects to install your app from Google Play.

If Google Play is able to download the expansion files (which is the case for most
devices), it downloads them along with the APK.

If Google Play is unable to download the expansion files, it downloads the
APK only.

When the user launches your application, your app must check whether the expansion files are
already saved on the device.

If yes, your app is ready to go.

If no, your app must download the expansion files over HTTP from Google Play. Your app
must send a request to the Google Play client using the Google Play's Application Licensing service, which
responds with the name, file size, and URL for each expansion file. With this information, you then
download the files and save them to the proper storage location.

Caution: It is critical that you include the necessary code to
download the expansion files from Google Play in the event that the files are not already on the
device when your application starts. As discussed in the following section about Downloading the Expansion Files, we've made a library available to you that
greatly simplifies this process and performs the download from a service with a minimal amount of
code from you.

Development checklist

Here's a summary of the tasks you should perform to use expansion files with your
application:

First determine whether your application absolutely requires more than 50MB per installation.
Space is precious and you should keep your total application size as small as possible. If your app
uses more than 50MB in order to provide multiple versions of your graphic assets for multiple screen
densities, consider instead publishing multiple APKs in which each APK
contains only the assets required for the screens that it targets.

Determine which application resources to separate from your APK and package them in a
file to use as the main expansion file.

Normally, you should only use the second patch expansion file when performing updates to
the main expansion file. However, if your resources exceed the 2GB limit for the main
expansion file, you can use the patch file for the rest of your assets.

Develop your application such that it uses the resources from your expansion files in the
device's shared storage location.

Remember that you must not delete, move, or rename the expansion files.

If your application doesn't demand a specific format, we suggest you create ZIP files for
your expansion files, then read them using the APK Expansion Zip
Library.

Add logic to your application's main activity that checks whether the expansion files
are on the device upon start-up. If the files are not on the device, use Google Play's Application Licensing service to request URLs
for the expansion files, then download and save them.

To greatly reduce the amount of code you must write and ensure a good user experience
during the download, we recommend you use the Downloader
Library to implement your download behavior.

If you build your own download service instead of using the library, be aware that you
must not change the name of the expansion files and must save them to the proper
storage location.

Once you've finished your application development, follow the guide to Testing
Your Expansion Files.

Rules and Limitations

Adding APK expansion files is a feature available when you upload your application using the
Developer Console. When uploading your application for the first time or updating an
application that uses expansion files, you must be aware of the following rules and limitations:

Each expansion file can be no more than 2GB.

In order to download your expansion files from Google Play, the user must have
acquired your application from Google Play. Google Play will not
provide the URLs for your expansion files if the application was installed by other means.

When performing the download from within your application, the URL that Google Play
provides for each file is unique for every download and each one expires shortly after it is given
to your application.

If you update your application with a new APK or upload multiple APKs for the same
application, you can select expansion files that you've uploaded for a previous APK. The
expansion file's name does not change—it retains the version received by the APK to
which the file was originally associated.

If you use expansion files in combination with multiple APKs in order to
provide different expansion files for different devices, you still must upload separate APKs
for each device in order to provide a unique  versionCode
value and declare different filters for
each APK.

You cannot issue an update to your application by changing the expansion files
alone—you must upload a new APK to update your app. If your changes only
concern the assets in your expansion files, you can update your APK simply by changing the versionCode (and
perhaps also the versionName).

Do not save other data into your obb/
directory. If you must unpack some data, save it into the location specified by getExternalFilesDir().

Do not delete or rename the .obb expansion file (unless you're
performing an update). Doing so will cause Google Play (or your app itself) to repeatedly
download the expansion file.

When updating an expansion file manually, you must delete the previous expansion file.

Downloading the Expansion Files

In most cases, Google Play downloads and saves your expansion files to the device at the same
time it installs or updates the APK. This way, the expansion files are available when your
application launches for the first time. However, in some cases your app must download the
expansion files itself by requesting them from a URL provided to you in a response
from Google Play's Application Licensing service.

The basic logic you need to download your expansion files is the following:

When your application starts, look for the expansion files on the shared storage location (in the
Android/obb/<package-name>/ directory).

If the expansion files are there, you're all set and your application can continue.

If the expansion files are not there:

Perform a request using Google Play's Application Licensing to get your
app's expansion file names, sizes, and URLs.

Use the URLs provided by Google Play to download the expansion files and save
the expansion files. You must save the files to the shared storage location
(Android/obb/<package-name>/) and use the exact file name provided
by Google Play's response.

Note: The URL that Google Play provides for your
expansion files is unique for every download and each one expires shortly after it is given to
your application.

If your application is free (not a paid app), then you probably haven't used the Application Licensing service. It's primarily
designed for you to enforce
licensing policies for your application and ensure that the user has the right to
use your app (he or she rightfully paid for it on Google Play). In order to facilitate the
expansion file functionality, the licensing service has been enhanced to provide a response
to your application that includes the URL of your application's expansion files that are hosted
on Google Play. So, even if your application is free for users, you need to include the
License Verification Library (LVL) to use APK expansion files. Of course, if your application
is free, you don't need to enforce license verification—you simply need the
library to perform the request that returns the URL of your expansion files.

Note: Whether your application is free or not, Google Play
returns the expansion file URLs only if the user acquired your application from Google Play.

In addition to the LVL, you need a set of code that downloads the expansion files
over an HTTP connection and saves them to the proper location on the device's shared storage.
As you build this procedure into your application, there are several issues you should take into
consideration:

The device might not have enough space for the expansion files, so you should check
before beginning the download and warn the user if there's not enough space.

File downloads should occur in a background service in order to avoid blocking the user
interaction and allow the user to leave your app while the download completes.

A variety of errors might occur during the request and download that you must
gracefully handle.

Network connectivity can change during the download, so you should handle such changes and
if interrupted, resume the download when possible.

While the download occurs in the background, you should provide a notification that
indicates the download progress, notifies the user when it's done, and takes the user back to
your application when selected.

To simplify this work for you, we've built the Downloader Library,
which requests the expansion file URLs through the licensing service, downloads the expansion files,
performs all of the tasks listed above, and even allows your activity to pause and resume the
download. By adding the Downloader Library and a few code hooks to your application, almost all the
work to download the expansion files is already coded for you. As such, in order to provide the best
user experience with minimal effort on your behalf, we recommend you use the Downloader Library to
download your expansion files. The information in the following sections explain how to integrate
the library into your application.

If you'd rather develop your own solution to download the expansion files using the Google
Play URLs, you must follow the Application
Licensing documentation to perform a license request, then retrieve the expansion file names,
sizes, and URLs from the response extras. You should use the APKExpansionPolicy class (included in the License Verification Library) as your licensing
policy, which captures the expansion file names, sizes, and URLs from the licensing service..

About the Downloader Library

To use APK expansion files with your application and provide the best user experience with
minimal effort on your behalf, we recommend you use the Downloader Library that's included in the
Google Play APK Expansion Library package. This library downloads your expansion files in a
background service, shows a user notification with the download status, handles network
connectivity loss, resumes the download when possible, and more.

To implement expansion file downloads using the Downloader Library, all you need to do is:

Extend a special Service subclass and BroadcastReceiver subclass that each require just a few
lines of code from you.

Add some logic to your main activity that checks whether the expansion files have
already been downloaded and, if not, invokes the download process and displays a
progress UI.

Implement a callback interface with a few methods in your main activity that
receives updates about the download progress.

The following sections explain how to set up your app using the Downloader Library.

Preparing to use the Downloader Library

To use the Downloader Library, you need to
download two packages from the SDK Manager and add the appropriate libraries to your
application.

First, open the Android SDK Manager, expand
Extras and download:

Google Play Licensing Library package

Google Play APK Expansion Library package

If you're using Eclipse, create a project for each library and add it to your app:

Create a new Library Project for the License Verification Library and Downloader
Library. For each library:

Begin a new Android project.

Select Create project from existing
source and choose the library from the <sdk>/extras/google/ directory
(market_licensing/ for the License Verification Library or market_apk_expansion/downloader_library/ for the Downloader Library).

Specify a Project Name such as "Google Play License Library" and "Google Play
Downloader
Library"

Click Finish.

Note: The Downloader Library depends on the License
Verification Library. Be sure to add the License
Verification Library to the Downloader Library's project properties (same process as
steps 2 and 3 below).

Right-click the Android project in which you want to use APK expansion files and
select Properties.

In the Library panel, click Add to select and add each of the
libraries to your application.

Or, from a command line, update your project to include the libraries:

Change directories to the <sdk>/tools/ directory.

Execute android update project with the --library option to add both the
LVL and the Downloader Library to your project. For example:

android update project --path ~/Android/MyApp \
--library ~/android_sdk/extras/google/market_licensing \
--library ~/android_sdk/extras/google/market_apk_expansion/downloader_library

With both the License Verification Library and Downloader Library added to your
application, you'll be able to quickly integrate the ability to download expansion files from
Google Play. The format that you choose for the expansion files and how you read them
from the shared storage is a separate implementation that you should consider based on your
application needs.

Tip: The Apk Expansion package includes a sample
application
that shows how to use the Downloader Library in an app. The sample uses a third library
available in the Apk Expansion package called the APK Expansion Zip Library. If
you plan on
using ZIP files for your expansion files, we suggest you also add the APK Expansion Zip Library to
your application. For more information, see the section below
about Using the APK Expansion Zip Library.

Declaring user permissions

In order to download the expansion files, the Downloader Library
requires several permissions that you must declare in your application's manifest file. They
are:

<manifest ...>
    <!-- Required to access Google Play Licensing -->
    <uses-permission android:name="com.android.vending.CHECK_LICENSE" />

    <!-- Required to download files from Google Play -->
    <uses-permission android:name="android.permission.INTERNET" />

    <!-- Required to keep CPU alive while downloading files (NOT to keep screen awake) -->
    <uses-permission android:name="android.permission.WAKE_LOCK" />

    <!-- Required to poll the state of the network connection and respond to changes -->
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

    <!-- Required to check whether Wi-Fi is enabled -->
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

    <!-- Required to read and write the expansion files on shared storage -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    ...
</manifest>

Note: By default, the Downloader Library requires API
level 4, but the APK Expansion Zip Library requires API level 5.

Implementing the downloader service

In order to perform downloads in the background, the Downloader Library provides its
own Service subclass called DownloaderService that you should extend. In
addition to downloading the expansion files for you, the DownloaderService also:

Registers a BroadcastReceiver that listens for changes to the
device's network connectivity (the CONNECTIVITY_ACTION
broadcast) in order to pause the download when necessary (such as due to connectivity loss) and
resume the download when possible (connectivity is acquired).

Schedules an RTC_WAKEUP alarm to retry the download for
cases in which the service gets killed.

Builds a custom Notification that displays the download progress and
any errors or state changes.

Allows your application to manually pause and resume the download.

Verifies that the shared storage is mounted and available, that the files don't already exist,
and that there is enough space, all before downloading the expansion files. Then notifies the user
if any of these are not true.

All you need to do is create a class in your application that extends the DownloaderService class and override three methods to provide specific application details:

getPublicKey()

This must return a string that is the Base64-encoded RSA public key for your publisher
account, available from the profile page on the Developer Console (see Setting Up for Licensing).

getSALT()

This must return an array of random bytes that the licensing Policy uses to
create an Obfuscator. The salt ensures that your obfuscated SharedPreferences
file in which your licensing data is saved will be unique and non-discoverable.

getAlarmReceiverClassName()

This must return the class name of the BroadcastReceiver in
your application that should receive the alarm indicating that the download should be
restarted (which might happen if the downloader service unexpectedly stops).

For example, here's a complete implementation of DownloaderService:

public class SampleDownloaderService extends DownloaderService {
    // You must use the public key belonging to your publisher account
    public static final String BASE64_PUBLIC_KEY = "YourLVLKey";
    // You should also modify this salt
    public static final byte[] SALT = new byte[] { 1, 42, -12, -1, 54, 98,
            -100, -12, 43, 2, -8, -4, 9, 5, -106, -107, -33, 45, -1, 84
    };

    @Override
    public String getPublicKey() {
        return BASE64_PUBLIC_KEY;
    }

    @Override
    public byte[] getSALT() {
        return SALT;
    }

    @Override
    public String getAlarmReceiverClassName() {
        return SampleAlarmReceiver.class.getName();
    }
}

Notice: You must update the BASE64_PUBLIC_KEY value
to be the public key belonging to your publisher account. You can find the key in the Developer
Console under your profile information. This is necessary even when testing
your downloads.

Remember to declare the service in your manifest file:

<application ...>
    <service android:name=".SampleDownloaderService" />
    ...
</application>

Implementing the alarm receiver

In order to monitor the progress of the file downloads and restart the download if necessary, the
DownloaderService schedules an RTC_WAKEUP alarm that
delivers an Intent to a BroadcastReceiver in your
application. You must define the BroadcastReceiver to call an API
from the Downloader Library that checks the status of the download and restarts
it if necessary.

You simply need to override the onReceive() method to call DownloaderClientMarshaller.startDownloadServiceIfRequired().

For example:

public class SampleAlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        try {
            DownloaderClientMarshaller.startDownloadServiceIfRequired(context, intent,
                    SampleDownloaderService.class);
        } catch (NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Notice that this is the class for which you must return the name
in your service's getAlarmReceiverClassName() method (see the previous section).

Remember to declare the receiver in your manifest file:

<application ...>
    <receiver android:name=".SampleAlarmReceiver" />
    ...
</application>

Starting the download

The main activity in your application (the one started by your launcher icon) is
responsible for verifying whether the expansion files are already on the device and initiating
the download if they are not.

Starting the download using the Downloader Library requires the following
procedures:

Check whether the files have been downloaded.

The Downloader Library includes some APIs in the Helper class to
help with this process:

getExpansionAPKFileName(Context, c, boolean mainFile, int
versionCode)

doesFileExist(Context c, String fileName, long fileSize)

For example, the sample app provided in the Apk Expansion package calls the
following method in the activity's onCreate() method to check
whether the expansion files already exist on the device:

boolean expansionFilesDelivered() {
    for (XAPKFile xf : xAPKS) {
        String fileName = Helpers.getExpansionAPKFileName(this, xf.mIsBase, xf.mFileVersion);
        if (!Helpers.doesFileExist(this, fileName, xf.mFileSize, false))
            return false;
    }
    return true;
}

In this case, each XAPKFile object holds the version number and file size of a known
expansion file and a boolean as to whether it's the main expansion file. (See the sample
application's SampleDownloaderActivity class for details.)

If this method returns false, then the application must begin the download.

Start the download by calling the static method DownloaderClientMarshaller.startDownloadServiceIfRequired(Context c, PendingIntent
notificationClient, Class<?> serviceClass).

The method takes the following parameters:

context: Your application's Context.

notificationClient: A PendingIntent to start your main
activity. This is used in the Notification that the DownloaderService
creates to show the download progress. When the user selects the notification, the system
invokes the PendingIntent you supply here and should open the activity
that shows the download progress (usually the same activity that started the download).

serviceClass: The Class object for your implementation of
DownloaderService, required to start the service and begin the download if necessary.

The method returns an integer that indicates
whether or not the download is required. Possible values are:

NO_DOWNLOAD_REQUIRED: Returned if the files already
exist or a download is already in progress.

LVL_CHECK_REQUIRED: Returned if a license verification is
required in order to acquire the expansion file URLs.

DOWNLOAD_REQUIRED: Returned if the expansion file URLs are already known,
but have not been downloaded.

The behavior for LVL_CHECK_REQUIRED and DOWNLOAD_REQUIRED are essentially the
same and you normally don't need to be concerned about them. In your main activity that calls startDownloadServiceIfRequired(), you can simply check whether or not the response is NO_DOWNLOAD_REQUIRED. If the response is anything other than NO_DOWNLOAD_REQUIRED,
the Downloader Library begins the download and you should update your activity UI to
display the download progress (see the next step). If the response is NO_DOWNLOAD_REQUIRED, then the files are available and your application can start.

For example:

@Override
public void onCreate(Bundle savedInstanceState) {
    // Check if expansion files are available before going any further
    if (!expansionFilesDelivered()) {
        // Build an Intent to start this activity from the Notification
        Intent notifierIntent = new Intent(this, MainActivity.getClass());
        notifierIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                                Intent.FLAG_ACTIVITY_CLEAR_TOP);
        ...
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
                notifierIntent, PendingIntent.FLAG_UPDATE_CURRENT);

        // Start the download service (if required)
        int startResult = DownloaderClientMarshaller.startDownloadServiceIfRequired(this,
                        pendingIntent, SampleDownloaderService.class);
        // If download has started, initialize this activity to show download progress
        if (startResult != DownloaderClientMarshaller.NO_DOWNLOAD_REQUIRED) {
            // This is where you do set up to display the download progress (next step)
            ...
            return;
        } // If the download wasn't necessary, fall through to start the app
    }
    startApp(); // Expansion files are available, start the app
}

When the startDownloadServiceIfRequired() method returns anything other
than NO_DOWNLOAD_REQUIRED, create an instance of IStub by
calling DownloaderClientMarshaller.CreateStub(IDownloaderClient client, Class<?>
downloaderService). The IStub provides a binding between your activity to the downloader
service such that your activity receives callbacks about the download progress.

In order to instantiate your IStub by calling CreateStub(), you must pass it
an implementation of the IDownloaderClient interface and your DownloaderService
implementation. The next section about Receiving download progress discusses
the IDownloaderClient interface, which you should usually implement in your Activity class so you can update the activity UI when the download state changes.

We recommend that you call CreateStub() to instantiate your IStub during your activity's onCreate() method, after startDownloadServiceIfRequired()
starts the download.

For example, in the previous code sample for onCreate(), you can respond to the startDownloadServiceIfRequired() result like this:

        // Start the download service (if required)
        int startResult = DownloaderClientMarshaller.startDownloadServiceIfRequired(this,
                        pendingIntent, SampleDownloaderService.class);
        // If download has started, initialize activity to show progress
        if (startResult != DownloaderClientMarshaller.NO_DOWNLOAD_REQUIRED) {
            // Instantiate a member instance of IStub
            mDownloaderClientStub = DownloaderClientMarshaller.CreateStub(this,
                    SampleDownloaderService.class);
            // Inflate layout that shows download progress
            setContentView(R.layout.downloader_ui);
            return;
        }

After the onCreate() method returns, your activity
receives a call to onResume(), which is where you should then
call connect() on the IStub, passing it your application's Context. Conversely, you should call
disconnect() in your activity's onStop() callback.

@Override
protected void onResume() {
    if (null != mDownloaderClientStub) {
        mDownloaderClientStub.connect(this);
    }
    super.onResume();
}

@Override
protected void onStop() {
    if (null != mDownloaderClientStub) {
        mDownloaderClientStub.disconnect(this);
    }
    super.onStop();
}

Calling connect() on the IStub binds your activity to the DownloaderService such that your activity receives callbacks regarding changes to the download
state through the IDownloaderClient interface.

Receiving download progress

To receive updates regarding the download progress and to interact with the DownloaderService, you must implement the Downloader Library's IDownloaderClient interface.
Usually, the activity you use to start the download should implement this interface in order to
display the download progress and send requests to the service.

The required interface methods for IDownloaderClient are:

onServiceConnected(Messenger m)

After you instantiate the IStub in your activity, you'll receive a call to this
method, which passes a Messenger object that's connected with your instance
of DownloaderService. To send requests to the service, such as to pause and resume
downloads, you must call DownloaderServiceMarshaller.CreateProxy() to receive the IDownloaderService interface connected to the service.

A recommended implementation looks like this:

private IDownloaderService mRemoteService;
...

@Override
public void onServiceConnected(Messenger m) {
    mRemoteService = DownloaderServiceMarshaller.CreateProxy(m);
    mRemoteService.onClientUpdated(mDownloaderClientStub.getMessenger());
}

With the IDownloaderService object initialized, you can send commands to the
downloader service, such as to pause and resume the download (requestPauseDownload()
and requestContinueDownload()).

onDownloadStateChanged(int newState)

The download service calls this when a change in download state occurs, such as the
download begins or completes.

The newState value will be one of several possible values specified in
by one of the IDownloaderClient class's STATE_* constants.

To provide a useful message to your users, you can request a corresponding string
for each state by calling Helpers.getDownloaderStringResourceIDFromState(). This
returns the resource ID for one of the strings bundled with the Downloader
Library. For example, the string "Download paused because you are roaming" corresponds to STATE_PAUSED_ROAMING.

onDownloadProgress(DownloadProgressInfo progress)

The download service calls this to deliver a DownloadProgressInfo object,
which describes various information about the download progress, including estimated time remaining,
current speed, overall progress, and total so you can update the download progress UI.

Tip: For examples of these callbacks that update the download
progress UI, see the SampleDownloaderActivity in the sample app provided with the
Apk Expansion package.

Some public methods for the IDownloaderService interface you might find useful are:

requestPauseDownload()

Pauses the download.

requestContinueDownload()

Resumes a paused download.

setDownloadFlags(int flags)

Sets user preferences for network types on which its OK to download the files. The
current implementation supports one flag, FLAGS_DOWNLOAD_OVER_CELLULAR, but you can add
others. By default, this flag is not enabled, so the user must be on Wi-Fi to download
expansion files. You might want to provide a user preference to enable downloads over
the cellular network. In which case, you can call:

mRemoteService.setDownloadFlags(IDownloaderService.FLAGS_DOWNLOAD_OVER_CELLULAR);

Using APKExpansionPolicy

If you decide to build your own downloader service instead of using the Google Play
Downloader Library, you should still use the APKExpansionPolicy that's provided in the License Verification Library. The APKExpansionPolicy class is nearly identical to ServerManagedPolicy (available in the
Google Play License Verification Library) but includes additional handling for the APK expansion
file response extras.

Note: If you do use the Downloader Library as discussed in the previous section, the
library performs all interaction with the APKExpansionPolicy so you don't have to use
this class directly.

The class includes methods to help you get the necessary information about the available
expansion files:

getExpansionURLCount()

getExpansionURL(int index)

getExpansionFileName(int index)

getExpansionFileSize(int index)

For more information about how to use the APKExpansionPolicy when you're not
using the Downloader Library, see the documentation for Adding Licensing to Your App,
which explains how to implement a license policy such as this one.

Reading the Expansion File

Once your APK expansion files are saved on the device, how you read your files
depends on the type of file you've used. As discussed in the overview, your
expansion files can be any kind of file you
want, but are renamed using a particular file name format and are saved to
<shared-storage>/Android/obb/<package-name>/.

Regardless of how you read your files, you should always first check that the external
storage is available for reading. There's a chance that the user has the storage mounted to a
computer over USB or has actually removed the SD card.

Note: When your application starts, you should always check whether
the external storage space is available and readable by calling getExternalStorageState(). This returns one of several possible strings
that represent the state of the external storage. In order for it to be readable by your
application, the return value must be MEDIA_MOUNTED.

Getting the file names

As described in the overview, your APK expansion files are saved
using a specific file name format:

[main|patch].<expansion-version>.<package-name>.obb

To get the location and names of your expansion files, you should use the
getExternalStorageDirectory() and getPackageName() methods to construct the path to your files.

Here's a method you can use in your application to get an array containing the complete path
to both your expansion files:

// The shared path to all app expansion files
private final static String EXP_PATH = "/Android/obb/";

static String[] getAPKExpansionFiles(Context ctx, int mainVersion, int patchVersion) {
    String packageName = ctx.getPackageName();
    Vector<String> ret = new Vector<String>();
    if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
        // Build the full path to the app's expansion files
        File root = Environment.getExternalStorageDirectory();
        File expPath = new File(root.toString() + EXP_PATH + packageName);

        // Check that expansion file path exists
        if (expPath.exists()) {
            if ( mainVersion > 0 ) {
                String strMainPath = expPath + File.separator + "main." +
                        mainVersion + "." + packageName + ".obb";
                File main = new File(strMainPath);
                if ( main.isFile() ) {
                        ret.add(strMainPath);
                }
            }
            if ( patchVersion > 0 ) {
                String strPatchPath = expPath + File.separator + "patch." +
                        mainVersion + "." + packageName + ".obb";
                File main = new File(strPatchPath);
                if ( main.isFile() ) {
                        ret.add(strPatchPath);
                }
            }
        }
    }
    String[] retArray = new String[ret.size()];
    ret.toArray(retArray);
    return retArray;
}

You can call this method by passing it your application Context
and the desired expansion file's version.

There are many ways you could determine the expansion file version number. One simple way is to
save the version in a SharedPreferences file when the download begins, by
querying the expansion file name with the APKExpansionPolicy class's getExpansionFileName(int index) method. You can then get the version code by reading the SharedPreferences file when you want to access the expansion
file.

For more information about reading from the shared storage, see the Data Storage
documentation.

Using the APK Expansion Zip Library

Reading media files from a ZIP

If you're using your expansion files to store media files, a ZIP file still allows you to
use Android media playback calls that provide offset and length controls (such as MediaPlayer.setDataSource() and
SoundPool.load()). In order for
this to work, you must not perform additional compression on the media files when creating the ZIP
packages. For example, when using the zip tool, you should use the -n
option to specify the file suffixes that should not be compressed:

zip -n .mp4;.ogg main_expansion media_files

The Google Market Apk Expansion package includes a library called the APK
Expansion Zip Library (located in <sdk>/extras/google/google_market_apk_expansion/zip_file/). This is an optional library that
helps you read your expansion
files when they're saved as ZIP files. Using this library allows you to easily read resources from
your ZIP expansion files as a virtual file system.

The APK Expansion Zip Library includes the following classes and APIs:

APKExpansionSupport

Provides some methods to access expansion file names and ZIP files:

getAPKExpansionFiles()

The same method shown above that returns the complete file path to both expansion
files.

getAPKExpansionZipFile(Context ctx, int mainVersion, int
patchVersion)

Returns a ZipResourceFile representing the sum of both the main file and
patch file. That is, if you specify both the mainVersion and the
patchVersion, this returns a ZipResourceFile that provides read access to
all the data, with the patch file's data merged on top of the main file.

ZipResourceFile

Represents a ZIP file on the shared storage and performs all the work to provide a virtual
file system based on your ZIP files. You can get an instance using APKExpansionSupport.getAPKExpansionZipFile() or with the ZipResourceFile by passing it the
path to your expansion file. This class includes a variety of useful methods, but you generally
don't need to access most of them. A couple of important methods are:

getInputStream(String assetPath)

Provides an InputStream to read a file within the ZIP file. The
assetPath must be the path to the desired file, relative to
the root of the ZIP file contents.

getAssetFileDescriptor(String assetPath)

Provides an AssetFileDescriptor for a file within the
ZIP file. The assetPath must be the path to the desired file, relative to
the root of the ZIP file contents. This is useful for certain Android APIs that require  an AssetFileDescriptor, such as some MediaPlayer APIs.

APEZProvider

Most applications don't need to use this class. This class defines a ContentProvider that marshals the data from the ZIP files through a content
provider Uri in order to provide file access for certain Android APIs that
expect Uri access to media files. For example, this is useful if you want to
play a video with VideoView.setVideoURI().

Reading from a ZIP file

When using the APK Expansion Zip Library, reading a file from your ZIP usually requires the
following:

// Get a ZipResourceFile representing a merger of both the main and patch files
ZipResourceFile expansionFile = APKExpansionSupport.getAPKExpansionZipFile(appContext,
        mainVersion, patchVersion);

// Get an input stream for a known file inside the expansion file ZIPs
InputStream fileStream = expansionFile.getInputStream(pathToFileInsideZip);

The above code provides access to any file that exists in either your main expansion file or
patch expansion file, by reading from a merged map of all the files from both files. All you
need to provide the getAPKExpansionFile() method is your application android.content.Context and the version number for both the main expansion file and patch
expansion file.

If you'd rather read from a specific expansion file, you can use the ZipResourceFile constructor with the path to the desired expansion file:

// Get a ZipResourceFile representing a specific expansion file
ZipResourceFile expansionFile = new ZipResourceFile(filePathToMyZip);

// Get an input stream for a known file inside the expansion file ZIPs
InputStream fileStream = expansionFile.getInputStream(pathToFileInsideZip);

For more information about using this library for your expansion files, look at
the sample application's SampleDownloaderActivity class, which includes additional code to
verify the downloaded files using CRC. Beware that if you use this sample as the basis for
your own implementation, it requires that you declare the byte size of your expansion
files in the xAPKS array.

Testing Your Expansion Files

Before publishing your application, there are two things you should test: Reading the
expansion files and downloading the files.

Testing file reads

Before you upload your application to Google Play, you
should test your application's ability to read the files from the shared storage. All you need to do
is add the files to the appropriate location on the device shared storage and launch your
application:

On your device, create the appropriate directory on the shared storage where Google
Play will save your files.

For example, if your package name is com.example.android, you need to create
the directory Android/obb/com.example.android/ on the shared storage space. (Plug in
your test device to your computer to mount the shared storage and manually create this
directory.)

Manually add the expansion files to that directory. Be sure that you rename your files to
match the file name format that Google Play will use.

For example, regardless of the file type, the main expansion file for the com.example.android application should be main.0300110.com.example.android.obb.
The version code can be whatever value you want. Just remember:

The main expansion file always starts with main and the patch file starts with
patch.

The package name always matches that of the APK to which the file is attached on
Google Play.

Now that the expansion file(s) are on the device, you can install and run your application to
test your expansion file(s).

Here are some reminders about handling the expansion files:

Do not delete or rename the .obb expansion files (even if you unpack
the data to a different location). Doing so will cause Google Play (or your app itself) to
repeatedly download the expansion file.

Do not save other data into your obb/
directory. If you must unpack some data, save it into the location specified by getExternalFilesDir().

Testing file downloads

Because your application must sometimes manually download the expansion files when it first
opens, it's important that you test this process to be sure your application can successfully query
for the URLs, download the files, and save them to the device.

To test your application's implementation of the manual download procedure, you must upload
your application to Google Play as a "draft" to make your expansion files available for
download:

Upload your APK and corresponding expansion files using the Google Play Developer
Console.

Fill in the necessary application details (title, screenshots, etc.). You can come back and
finalize these details before publishing your application.

Click the Save button. Do not click Publish. This saves
the application as a draft, such that your application is not published for Google Play users,
but the expansion files are available for you to test the download process.

Install the application on your test device using the Eclipse tools or adb.

Launch the app.

If everything works as expected, your application should begin downloading the expansion
files as soon as the main activity starts.

Updating Your Application

One of the great benefits to using expansion files on Google Play is the ability to
update your application without re-downloading all of the original assets. Because Google Play
allows you to provide two expansion files with each APK, you can use the second file as a "patch"
that provides updates and new assets. Doing so avoids the
need to re-download the main expansion file which could be large and expensive for users.

The patch expansion file is technically the same as the main expansion file and neither
the Android system nor Google Play perform actual patching between your main and patch expansion
files. Your application code must perform any necessary patches itself.

If you use ZIP files as your expansion files, the APK Expansion Zip
Library that's included with the Apk Expansion package includes the ability to merge
your
patch file with the main expansion file.

Note: Even if you only need to make changes to the patch
expansion file, you must still update the APK in order for Google Play to perform an update.
If you don't require code changes in the application, you should simply update the versionCode in the
manifest.

As long as you don't change the main expansion file that's associated with the APK
in the Developer Console, users who previously installed your application will not
download the main expansion file. Existing users receive only the updated APK and the new patch
expansion file (retaining the previous main expansion file).

Here are a few issues to keep in mind regarding updates to expansion files:

There can be only two expansion files for your application at a time. One main expansion
file and one patch expansion file. During an update to a file, Google Play deletes the
previous version (and so must your application when performing manual updates).

When adding a patch expansion file, the Android system does not actually patch your
application or main expansion file. You must design your application to support the patch data.
However, the Apk Expansion package includes a library for using ZIP files
as expansion files, which merges the data from the patch file into the main expansion file so
you can easily read all the expansion file data.

  Except as noted, this content is
  licensed under
  Creative Commons Attribution 2.5. For details and
  restrictions, see the Content
  License.

    About Android  |
    Legal  |
    Support


text:
Runner's World+
Meet RW+ Members
Download Training Plans
RW Apparel
Runner's World 2023 Calendar
Health & Injuries
Daily Calories Calculator
Running Shoes & Gear
All Gear & Accessories
Shoe Guide
What to Wear Tool
GPS Running Watches
Socks for Runners
Winter Running Hats
Best Jogging Strollers
Running Headlamps
Start Running
Interval Running
Tempo Run
Race Times Predictor
Age Grade Calculator
Pace Converter
Training Pace Calculator
Calories Burned Calculator
Run Walk Pace Calculator
Races & Places
New York City Marathon
Runner's Stories
Trail Running Gear
This Sports-Drink Trick Is Weird, But It'll Help You Finish Strong
Use This Drink Trick to Finish Strong
Here's more evidence that rinsing with a carbohydrate drink boosts performance.
by Scott Douglas Published: Jan 17, 2018
If you've watched enough major marathons, you may have noticed a seeming oddity: Some elites grab their fluid bottles at the 40K mark, even though they're going to finish only six or seven minutes later. What's the point?
Look carefully, and you'll see that in many cases the runners appear to take a drink and spit it out. This practice is purposeful—over the last decade there's been increasing evidence that rinsing your mouth with a carbohydrate drink but not swallowing it can help you run faster. To date, most of the research on the topic has lacked a crucial real-world element, in that the athletes swishing and spitting were doing so after not having carbohydrates before or during exercise.
So kudos to the Canadian researchers whose new study shows that rinsing with a sports drink boosts performance even if you haven't been denying yourself carbs. In the study, published in Medicine & Science in Sports & Exercise, cyclists who rode at a steady effort for two hours before doing a 30-minute time trial performed almost 2 percent better on the time trial when they rinsed with a carb drink. According to the researchers, the trick can help not just at the end of long races but also during shorter workouts.
Check out this simple tip to efficiently grab fluids on race day.
First, a brief explainer: How does rinsing with a carbohydrate drink improve performance, given that you don't ingest the carbohydrates that would theoretically fuel your working muscles?
"Food is known to simulate mood and perception, and carbohydrate is a major food that has a great impact on mood/perception," Matt Jensen, from the University of Victoria and the lead researcher on the new study, wrote in an email. "So even without ingesting carbohydrate, our body is already at work responding to the idea that carbohydrate is about to enter the system. This has been backed up by looking at brain stimulation differences between carbohydrate and artificial sweeteners. You would think that since the artificial sweeteners are very sweet that the body would react to it, but that is not the case. The body only reacts to true carbohydrate."
As leading sport nutritionist Asker Jeukendrup has noted, many of us have experienced this phenomenon. If you feel dizzy and weak after a long run and then eat or drink something sugary, you'll feel better almost immediately "This means that there must be connections from the mouth directly to the brain," Jeukendrup writes. Jensen says these connections, signaling that carbs are on the way, "then trick the body into doing more, because the brain is always trying to limit damage, and if it thinks carbohydrate is limited, it will reduce muscle activation, etc."
RELATED: How to Find the Sports Drink That Works For You
Again, though, most previous research on the practice introduced an artificial condition of not allowing carbs before and during the rinse-and-spit hard effort. In that situation, it makes sense that your brain would be looking for any sign it can get that carbs are on the way. But that's not how most people go about something like a half marathon or marathon. Instead, you probably eat a light breakfast a few hours before the race and you take in carbs, via drinks and/or gels, during the race.
In the new study, the cyclists did the 2.5-hour ride (two hours at steady effort, then the time trial) on two occasions. Both times, they ate a snack two hours before the ride, and took in 30 grams of carbohydrate during the first two hours of the ride. (Thirty grams of carbohydrate provides 120 calories, which is a little more than the amount provided by many energy gels or 12 to 20 ounces of store-bought carbohydrate drink.) During the time trials, the cyclists rinsed several times for five to 10 seconds with a carbohydrate drink or a placebo that tasted the same. When they rinsed with carbs, they performed 1.7 percent better, with almost all of the improvement coming in the final minutes.
RW IN YOUR INBOX: Have the latest news, advice, and inspiration sent to you every day with our Runner's World Newsletters.
So, when does it make sense to rinse with sport drink instead of swallowing it? This brings us back to elite runners grabbing their fluid bottles with just more than a mile to go in a marathon. Rinsing at this point delivers the promise of carbs even when there's not time for the body to process them. Drinking in the last 20 to 40 minutes of a race might not make sense because of the time needed to absorb and transport the carbs to working muscles, Jensen says. If the new study's finding of a 1.7 percent performance boost at the end of a long effort doesn't sound significant, consider that's the difference between a 3:56 marathon and a 4:00 marathon.
More broadly, rinsing is a good option when your stomach might not be able to handle drinking. That extends rinsing's potential uses to not only the last several miles of a long run or race, but even to speed workouts, because other studies have found brief boosts in power output after rinsing. Give rinsing and spitting a try. What do you have to lose except a little sports drink?
Scott Douglas
Scott is a veteran running, fitness, and health journalist who has held senior editorial positions at Runner's World and Running Times. Much of his writing translates sport science research and elite best practices into practical guidance for everyday athletes. He is the author or coauthor of several running books, including Running Is My Therapy, Advanced Marathoning, and Meb for Mortals. Scott has also written about running for Slate, The Atlantic, the Washington Post, and other members of the sedentary media. His lifetime running odometer is past 110,000 miles, but he's as much in love as ever.
Two American Records Fall in Boston
Orlando Runner Hit By Driver, Waits Hours for Help
Innes FitzGerald Not Going to XC Worlds
Hong Kong Marathon Offers Prizes to Non-Pros
Jogger Helps Saves Dog Trapped Under Rocks
Elite Fields Announced For 2023 Tokyo Marathon
Woman Runs a Marathon in 150 Consecutive Days
FBI Assists in Fraud Case Involving Usain Bolt
Running Influencer Bandits the Houston Marathon
Pregnant Runners Can Defer Boston Marathon Entry
Strava Clarifies Price Changes in Formal Statement
Should You Run Before or After a Strength Workout?
NewsletterPress RoomWriter GuidelinesGive A GiftCustomer ServiceSubscribeAdvertise OnlineOther Hearst Subscriptions

redpajama_set_name: RedPajamaCommonCrawl


text:
package org.wso2.developerstudio.eclipse.gmf.esb.diagram.custom.provider;

import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
import org.eclipse.emf.edit.provider.IItemPropertySource;
import org.eclipse.emf.edit.ui.provider.PropertySource;
import org.eclipse.ui.views.properties.IPropertyDescriptor;

/**
 * A custom {@link PropertySource} class.
 */
public class CustomPropertySource extends PropertySource {
    /**
     * Creates a new {@link CustomPropertySource} instance.
     *
     * @param object property container object.
     * @param itemPropertySource {@link IItemPropertySource} instance.
     */
    public CustomPropertySource(Object object, IItemPropertySource itemPropertySource) {
        super(object, itemPropertySource);
    }

    /**
     * {@inheritDoc}
     */
    protected IPropertyDescriptor createPropertyDescriptor(IItemPropertyDescriptor itemPropertyDescriptor) {
        return new CustomPropertyDescriptor(this.object, itemPropertyDescriptor);
    }
}

redpajama_set_name: RedPajamaGithub


text:
MUMBAI ART ROOM
Pipewala Building
Fourth Pasta Lane, Colaba
Mumbai 400 005, India
office@mumbaiartroom.org
Tuesday – Saturday 11am – 7pm
Mutarerium
13 June - 31 August 2019
With Mustafa Khanbhai, Priyanka D'Souza and Waylon James D'Souza
Curated by Adwait Singh
'Mutarerium' is a portmanteau derived from the Latin verb 'mutare' meaning to change or exchange, and terrarium, an independent glass unit for growing plants. As such it connotes the imagery of our planet as a mutating terrarium, or at the very least, a closed system within which life is mutating in perceptible and imperceptible ways. Seen against the backdrop of the Sixth extinction or Anthropocene extinction, where we stand to lose up to 50% – 95% of our biodiversity, the darkly glowing orb that is our planet appears to be in a state of suspended animation. In all probability, life would, as it has before, find a way in spite of human intervention, but the critical question is would it be life as we know it? Can we get used to the new way of living and would this living be so much living as languishing? Would there be a 'we' to pose that question from? Both dystopian and cautionary in intent, the project proffers alternative pathways, non-linear models of growth that are tentacular and symbiotic, as derived from fellow critters who predate our existence on the planet and profess better promise of riding out the ecological turbulence ahead.
What unites the artists in this exhibition is their interdisciplinary research-driven approach at extrapolating more-than-human evolutionary strands – be it of whales, dolphins, lizards or strangler figs – that nonetheless convey the weight of human-wrought devastation as well as the urgency of holistic, de-centred environmental action and policy making.
This Curatorial Lab and exhibition has been supported by Inlaks India Foundation, RRO and Kamalnayan Bajaj Art Gallery and Hall
Adwait Singh
Adwait Singh is an independent curator and theorist based out of New Delhi. His work as scholar-curator frequently weaves in and out of areas of inquiry such as subjectivity formation, gender and sexuality, posthumanism, contemporary technogenesis and ecofeminism. Shortly after completing his Master's at Goldsmiths, he seized the opportunity to be a part of the Students' Biennale 2016 and has since facilitated different art projects and workshops for/with young artistic practitioners across the country for various non-profit organisations. Recent curations include 'Caressing History' – a group show investigating the possibility of a body-based historiography for Prameya Art Foundation (New Delhi, 2018). As an art writer Adwait has been devoting time theorising and documenting independent exhibitions and alternative art practices.
Mustafa Khanbhai
Mustafa Khanbhai is a visual artist based in New Delhi. He completed his Bachelors in Visual Art at MS University Baroda in 2015 and his Masters in Visual Art at Ambedkar University Delhi in 2018. He works primarily in digital and sculptural media, particularly 3D animation. His research-intensive work is concerned with vestiges and reminders from periods of cataclysmic change in both human and natural history. He has exhibited in galleries, festivals, and various pop-up spaces across India.
Priyanka D'Souza
Mumbai-based artist Priyanka D'Souza, has graduated from the Painting department, M. S. University of Baroda in 2017. She is a recipient of the Nasreen Mohamedi and Kalpana Reddy award from her alma mater. She is also a fellow at the Dara Shikoh Fellowship, Srinagar and has participated in the Ladakh Bird Festival organized by Ladakh Arts and Media Organisation (LAMO) in collaboration with the Dara Shikoh Center in Leh (2018). She has trained in miniature painting under Aisha Khalid on a grant at the International Summer Academy of Fine Arts, Salzburg. She has shown her work in various group shows in Delhi and India Art Fair with Latitude 28.
Waylon James D'Souza
Waylon James D'Souza is a Goa-based artist and designer with a research-driven practice. He collates principles of education, philosophy and culture to iterate pan-disciplinary experiments in sustainability science. His creations advance environmental solutions through materially symbolic and visually compelling works. Waylon is trained in a matrix of symbiotic disciplines including fine arts, animation, aquaponics, permaculture as well as industrial design. The core tenets of restorative balance and interconnectivity manifest inventively in his diverse canon of work. The artist dextrously mobilises versatile materials, technical study and tactical hacks to create multi-media art including in-situ installations, bio-remedial products, performance pieces and works on paper. Each composition highlights crises in the ecological paradigm while offering original possibilities for social and scientific remediation.


Computer Forensic Investigation |Forensic date recovery | Computer forensic specialist | Computer forensic examiner.
One of the key elements in every data forensics procedure is time. Users may unintentionally or inadvertently overwrite evidence simply by continuing to complete their daily tasks. Optimal Intelligence will quickly and cost-effectively collect and preserve data or evidence that may have been deleted or become inaccessible through normal computing methods. Optimal Intelligence can determine if certain information exists and, if so, where it might be located.
When the data storage media is recovered either on location or at our lab facility, an accurate audit trail commences. The media is immediately logged into a tracking system and a log is produced. This log, suitable for all legal proceedings, accompanies the media throughout the recovery process. Optimal Intelligence employees who handle the media ensure the continuity of evidence by adding their name, signature, date and a detailed description of what was done.
At this stage of the process, Federal Rules of Evidence apply. Optimal Intelligence's expertise in magnetic media storage devices begins to play a crucial role. First - the media is replicated exactly by a bit-by-bit acquisition process ensuring the integrity of the subject media is intact, and evidence preserved. Optimal Intelligence then works only with duplicate copies ensuring that no contamination of the original data takes place.
In this preliminary examination, Optimal Intelligence provides the client a detailed report outlining file structures, media integrity, and the recoverability of deleted files. This report may be used to determine if the files present will be of assistance in the investigation. Optimal Intelligence will then make recommendations how to proceed if further information needs to be retrieved. This report allows our clients to make an informed decision on the various options that may be available to them. The client's needs augmented with our recommendations assure that the time spent on the analyses is focused at all times.


text:
Unilever partners with Flytrex for drone ice cream deliveries
By Katy Askew
Unilever's ice cream drone delivery with Flytrex / Pic: Flytrex
Related tags on-demand delivery Unilever Ice cream drone delivery
Unilever's first ever digital storefront, The Ice Cream Shop, plans to take to the skies in partnership with Flytrex for its latest foray in ultrafast on-demand delivery.
Consumers who place their order using the Flytrex app can expect a drone delivery of Unilever ice cream brands to their 'front and backyards' within three minutes. The app provides customers with 'real time updates' along the delivery route until the package is lowered from the drone 'safely by wire'.
Unilever's drive into on-demand ice cream
Unilever's The Ice Cream Shop is its first virtual storefront. It carries ice cream brands including Ben & Jerry's, Breyers, Good Humor, Klondike, Magnum, Popsicle and Talenti.
Russel Lilly, General Manager of Unilever's North American ice cream business, said that Flytrex is the CPG giants 'first ever drone delivery partner' bringing The Ice Cream Shop to 'new heights'. "Not only are we providing an exciting, innovative and ultra-fast way for ice cream fans to enjoy their favorite Unilever ice cream brands, but The Ice Cream Shop and Flytrex have exclusive ice cream bundles available for purchase. Whether you need some treats to sweeten up your backyard BBQ or are craving a cookie crunch, we're ready to fly straight to your doorstep."
This new partnership is Unilever's latest experiment in on-demand delivery. Last month, group announced The Ice Cream Shop is also partnering with food tech group Robomart to trial on-demand mobile mini-marts in Los Angeles.
The more recently announced tie-up with Flytrex will be available across the delivery tech start-ups US locations: Holly Springs, Fayetteville and Raeford, North Carolina, and Granbury, Texas.
Drones will 'absolutely' shape the future of delivery
Flytrex is a business-to-consumer provider of autonomous delivery services. It claims to offer 'unmatched' delivery costs, ultra-fast delivery and 'greater reach than ever before'. For these reasons, Flytech CEO & Co-Founder Yariv Bash believes drones will 'absolutely' play an important role in the future of D2C delivery.
"On-demand delivery is seen as economically impractical in suburban and rural areas, where traditional couriers are only able to make around two deliveries per-hour. Flytrex is changing that by operating automated backyard drone deliveries in these underserved areas," he told DairyReporter. "Through the new partnership with Unilever's digital storefront, you can scream for ice cream and have it in just minutes."
This partnership is the latest in a series of milestones for Flytrex. Most recently, the ultrafast drone delivery company launched in Granbury, Texas, just outside of Dallas-Fort Worth. Flytrex has also been operating in the state of North Carolina since September 2020, beginning in Fayetteville, and expanding to the town of Raeford. In October 2021, Flytrex launched its third drone delivery station in the 'First in Flight' state at the Holly Springs Towne Center. Flytrex's delivery service is now available to 10,000 homes across North Carolina and Texas.
"Flytrex provides retailers and restaurants a seamless, almost instantaneous delivery experience. Moreover, the average flight time for an order with Flytrex is just over two minutes, allowing retailers to keep up with the growing pressures of the "on-demand age" while simultaneously keeping customers satisfied and sated. In addition to significantly cutting costs and delivery time, Flytrex's drones are 100% electric and autonomous, meaning less pollution and less congestion on the roads," Bash told us.
Regulation, safety and drone deliveries
The Ice Cream Shop service is operating in cooperation with long-time Flytrex partner Causey Aviation Unmanned under a Federal Aviation Administration (FAA) waiver allowing a delivery radius of one nautical mile. This means the drones can reach 'thousands of potential homes'. Flytrex and Causey conduct all flights while maintaining the highest safety standards, the company stressed.
"Drones are held to the same regulatory standards as the manned commercial aviation industry. In this way, drone delivery commercially requires a certification process akin to any other manned commercial aircraft," Bash explained.
"To meet these stringent safety standards, Flytrex has developed its own drone, ensuring full control over its design and manufacturing – down to the smallest bolt – much like a commercial aircraft."
The company also continues to work alongside regulators to tackle the remaining hurdles in drone regulation, we heard. "Flytrex works closely with regulators to help ensure the highest safety standards. It participated in the FAA's UAS Integration Pilot Program (IPP) which concluded in October 2020, and has continued with the FAA's subsequent initiative, BEYOND -- working with the North Carolina Department of Transportation to help tackle the remaining challenges of UAS integration and bring swift, affordable and sustainable on-demand drone delivery to more partners, communities and consumers across the country."
The Ice Cream Shop's exclusive bundles
If you live in the communities served by Flytrex, you'll have access not only to swift ice cream delivery, consumers will also be able to order exclusive ice cream bundles delivered to their homes. These include:
Chocolate Lovers Bundle featuring Breyers Chocolate Truffle, Klondike Original Vanilla Bar, Magnum Mini Double Caramel Bars, Popsicle Fudgsicle, Ben & Jerry's Chocolate Fudge Brownie
Cookie Crunch Bundle featuring Breyers Cookies & Cream, Klondike Vanilla Sandwich, Talenti Caramel Cookie Crunch, Ben & Jerry's Milk & Cookies, Ben & Jerry's Chocolate Chip Cookie Dough
Backyard BBQ Bundle featuring Breyers Natural Vanilla, Breyers Chocolate, Good Humor Strawberry Shortcake Bars, Popsicle Grape, Cherry, Orange Pops, Klondike Vanilla Sandwich, Ben & Jerry's Phish Food, Ben & Jerry's Americone Dream
Berry Fruity Bundle featuring Breyers Strawberry, Good Humor Strawberry Shortcake Bars, Popsicle Grape, Cherry, Orange Pops, Talenti Roman Raspberry, Ben & Jerry's Strawberry Cheesecake
Ice Cream Favorites Bundle featuring Ben & Jerry's Half Baked, Breyers Natural Vanilla, Klondike Original Vanilla Bar, Magnum Ice Cream Bars Double Caramel
Ben & Jerry's Favorites Bundle featuring Ben & Jerry's Half Baked, Ben & Jerry's Chocolate Fudge Brownie, Ben & Jerry's Cherry Garcia, Ben & Jerry's Chocolate Chip Cookie Dough
Related topics R&D Ice Cream Unilever
Judge rules against Ben & Jerry's in Israel licensing case
Ice cream sector explores new delivery and storage innovations
Summer trends: What's hot in ice cream?
Unilever pilots Robomart automated on-demand delivery to 'revolutionize' the ice cream truck


Play Sniper Games? Play the best games on GamesXL.
Play free Sniper Games online every day. The coolest games, especially for you! Select a game to play!
As a sniper the enemy can't see you. When you start shooting, they'll know how to find you. That's why you need to to try to eliminate the enemy with one shot. Sometimes you need to zoom in to see the enemy.


Three generations of reticulated giraffes are interacting on an African savanna. Females start breeding at around five years old, and gestation is about 15 months. Calves are born from a standing female, dropping six feet to the ground! They weigh 100 to 150 pounds, and are six feet tall at birth.
Copyright © 2005 by The McGraw-Hill Companies, Inc. All rights reserved. Except as permitted under the United States Copyright Act,no part of this publication may be reproduced or distributed in any form or by any means,or stored in a database or retrieval system, without prior written permission of the publisher.
The National Geographic features were designed and developed by the National Geographic Society's Education Division.Copyright © National Geographic Society.The name "National Geographic Society" and the Yellow Border Rectangle are trademarks of the Society,and their use,without prior written permission,is strictly prohibited.
The "Science and Society"and the "Science and History"features that appear in this book were designed and developed by TIME School Publishing,a division of TIME Magazine.TIME and the red border are trademarks of Time Inc. All rights reserved.


text:
Warren Spector on today's games: "People are building games of choice and consequence and I couldn't be happier"
Take a gander at Dishonored, Gamescom's best game this year. It's as if Arkane built it in another universe – one in which developers really had spent the last decade thinking about and iterating on the achievements of Looking Glass and Ion Storm's best, just like we expected they would at the time.
Truly, it's a good time to be ogling video games. And the fact hasn't escaped Warren Spector.
"A lot of people are making big open world games now, and a lot of people who are building games of choice and consequence and I couldn't be happier," Spector told The Guardian Games Blog.Twenty years ago I remember sitting there with the guys at Origin and the guys at Looking Glass and saying, 'Why isn't everybody doing this?' We would look at each other and say, 'Why isn't everybody else making games like we do?' And now everybody is, which is cool."
The 'big open' part of these games comes at a price, though, says Spector: "I'm kind of an inch wide, mile deep sort of guy. There are people who are trying to simulate massive worlds at a level of an inch per mile, and I don't get it. I really want deep worlds that you can interact with. My ideal game would be one city block – some day I'm going to make that."
Dishonored System Requirements


text:
Coginchaug High choir to sing with legendary rockers Foreigner at Durham Fair
Coginchaug High School choir to sing with legendary rock band Foreigner
Bryan Ethier bryanethier@att.net
1of74Mick Jones and Bruce Watson during the second part of Foreigner's European tour this yearWacken-Romona Makwka photo Show MoreShow Less
2of74Members of the Coginchaug Regional High School chorus will back up legendary rockers Foreigner Saturday night at the Durham Fair when the band plays "I Want to Know What Love Is." Shown is Foreigner's Laurence Harvey in London.Contributed Photo Show MoreShow Less
4of74Foreigner plays Munich for Global Concerts.Contributed Photo Show MoreShow Less
5of74Kelly Hansen, Sheffield 2014Photo by Damian TwiggShow MoreShow Less
7of74Tom Gimbel, Sheffield 2014 Photo by Damian TwiggJournal Register Co.Show MoreShow Less
8of74Kelly Hansen, frontman at Sheffield 2014Photo by Damian TwiggShow MoreShow Less
10of74Brenda De Los Santos | The Middletown Press Madison Burt, five, left, and Melissa Fowler, 7, both of Rockfall, eat a healthy snack of roasted corn from the John Lyman School booth at the Durham Fair on Friday. 09.26.08 09.27.08 Show MoreShow Less
11of74Brenda De Los Santos | The Middletown Press Fried Dough from the Killingworth Lions Club booth at the Durham Fair on Friday. 09.26.08 09.27.08 Show MoreShow Less
12of74
13of74Three Vietnamese Pot-Bellied pigs from Robinson's Racing Pigs, based in Florida, head for a trough of water while racing at the Haddam Neck Fair on Sunday................TW photo....................9/1/02. Show MoreShow Less
14of74Rebecca Groves, 7, of Wallingford can only wait and listen to the rain as Monday's Haddam Neck Fair is pretty much a wash out, preventing her from showing her two cows. Rebecca and several others slept at the fair all weekend..............TW photo................9/2/02.............MPfair.jpg Show MoreShow Less
16of74Arnold Chapell of Salem, Ct. works his oxen in the oxen pull at the Durham Fair on Friday..............Tom Warren photo......9/28/01..........MPfai2.jpg Show MoreShow Less
17of74Brenda De Los Santos | The Middletown Press Jim DeBacco, Superintendent of Great Pumpkins for the Durham Fair, stands with the first prize-winning, 1,353 pound pumpkin on Thursday. DeBacco's son, Matt, who is pursuing a Master's degree in agronomy from the University of Connecticut, grew the prize winning pumpkin, which beat out Mark Lombardi's 1,246 pound pumpkin that took second place, in an East Lyme field. 09.25.08 09.26.08 Show MoreShow Less
19of74 Show MoreShow Less
20of74Ashley Yedynak, 15, receives a kiss from her boyfriend Kyle Davis, 17, while clutching a stuffed bear that Kyle won for her at the Durham Fair on Sunday. Kyle is eating an apple crisp and he won the bear by throwing darts at balloons.............Tom Warren photo..............9/30/01........MPfai2.jpg Show MoreShow Less
22of74The Coginchaug Dixieland Comb performs at the Durham Fair on Sunday..............Tom Warren photo............9/30/01...........MPfai1.jpg Show MoreShow Less
23of74Brenda De Los Santos | The Middletown Press Fairgoers enjoy fries and nachos at the Durham Fair on Friday. 09.26.08 09.27.08 Show MoreShow Less
25of74Brenda De Los Santos | The Middletown Press 13-year-olds Cody Hendly and Sean Rogers, both of Middlefield, and Bobby Jungels, of Durham, were not deterred by the non-stop rain at the Durham Fair on Friday. 09.26.08 09.27.08 Show MoreShow Less
26of74Norman Cox of Rockwell Amusements puts the "Convoy Race" ride together Wednesday in preparation for the Durham Fair which starts this week................TW Photo..........9/25/02..........MPfair.jpg Show MoreShow Less
28of74Great weather means great crowds at the Durham Fir on Saturday..............TW Photo............9/28/02...............MPfai2.jpg Show MoreShow Less
29of74Brenda De Los Santos | The Middletown Press The ground under the Crafts on the Green tent at the Durham Fair Friday was transformed into a muddy pool because of the incessant rain. Fair workers brought gravel in to battle the slippery ground just before noon on Friday. 09.26.08 09.27.08 Show MoreShow Less
31of74Brenda De Los Santos | The Middletown Press Pam Montes, of "Ginger Blue," a picture and frame vendor in the Crafts on the Green tent at the Durham Fair, sorts through her damaged inventory Just before noon on Friday. Heavy, persistent rain caused the ground around her booth, which she paid $1,800 to rent for the duration of the fair, to morph into a muddy pool, which Montes says resulted in the damage of thousands of dollars worth of her inventory. 09.26.08 09.27.08 Show MoreShow Less
32of74Brenda De Los Santos | The Middletown Press 15-year-old Leah Digloia and 17-year-old Cody Breault cury and card Memphis, a suffolk sheep, to get her ready for a show at the Durham Fair on Friday. 09.26.08 09.27.08 Show MoreShow Less
34of74Brenda De Los Santos | The Middletown Press Spectators watch as cattle are shown at the Durham Fair on Friday. 09.26.08 09.27.08 Show MoreShow Less
35of74Bill Barnum of Stratford lets one fly at the dunking booth at the Haddam Neck Fair on Sunday....................TW photo.............9/1/02................MPfair.jpg Show MoreShow Less
37of74Rita King of Cheshire and Bob Kaiser of Berlin stop to admire a large flag hanging at the Durham Fair on Friday............Tom Warren photo.......9/28/01......MPfai3.jpg Show MoreShow Less
38of74Catherine AvaloneShow MoreShow Less
53of74Durham resident Reba Larkin, 7, brushes her five-month old Jersey, Tiara Thursday evening at the Durham Fair. Larkin proudly refers to herself as a fair baby because her mom, Melynda Naples, owner of Deerfield Farm gave birth to her on closing night seven years ago. Catherine Avalone - The Middletown PressCatherine AvaloneShow MoreShow Less
55of74Catherine Avalone - The Middletown PressCatherine AvaloneShow MoreShow Less
56of74Thousands enjoy fair food, ox pulls, carnival rides, livestock showmanship and music at the 98 annual Durham Fair Friday, Sept. 26. (Viktoria Sundqvist/The Middletown Press) Show MoreShow Less
58of74Huntington, Mass. resident Ashley Owen, of Hidden Springs Ayrshires takes a break in the cattle barn at the Durham Fair Friday afternoon. Owen, 24, who has been to five other fairs this season said, "We have been doing pretty well. Hideway, one of her six ayrshires has been getting Jr. Champion this year." (Catherine Avalone - The Middletown Press)Catherine AvaloneShow MoreShow Less
59of74Thousands enjoy fair food, ox pulls, carnival rides, livestock showmanship and music at the 98 annual Durham Fair Friday, Sept. 26. (Catherine Avalone/The Middletown Press)Catherine AvaloneShow MoreShow Less
65of74Catherine Avalone | The Middletown Press 8.2.08 SEEN ON THE SCENE Rebecca Durinick, 8, of Haddam walked around the 82nd Middlesex & New Haven County 4H Fair with Buttercup, a mixed breed hen on her shoulder. Buttercup, who lays only one egg a day, won Reserved Champion Chicken in the Roosters and Hens category at the last show Rebecca entered. "I was there when Buttercup was born and the minute she opened her eyes, I knew then that we were mother and chicken", said Rebecca. Show MoreShow Less
67of74Catherine Avalone | The Middletown Press 8.2.08 SEEN ON THE SCENE Willow Coleman, 8, of Guilford holds Goldie, an Americana pullet. Willow explained a pullet is a chicken before it begans to lay eggs. Once a chicken lays eggs it becomes a hen. At left is Rosalie Coleman, who is 5 and anxiously waiting to be a Clover. Show MoreShow Less
68of74Catherine Avalone | The Middletown Press 8.2.08 SEEN ON THE SCENE Peter Marlowe, 10, of Guilford, talks to Catherine Owens, 8, center, and her twin sister, Erin, older by 39 minutes, of North Haven. In the background, Victoria Footit,8, of Middlefield plays a game on a cell phone while laying on Honey, a Holstein, at the 82nd Middlesex & New Haven County 4H Fair at the Durham Fairgrounds. Show MoreShow Less
70of74Catherine Avalone | The Middletown Press 9.23.11 Deep River resident Eli Dube', 11, cheek to cheek with his Jersey calf, Tulip as he waits int the wings for the Jr. Dairy Cattle Showmanship competition at the Cow Palace at the Durham Fair. Dube' is a member of the Jolly Ranchers 4H Club at Deerfield Farm in Durham. Show MoreShow Less
71of74Catherine Avalone | The Middletown Press 9.23.11 Rain did not put a damper of fairgoers at the Durham Fair Friday night. Show MoreShow Less
73of74Andrew Phillip Avalone | Special to the Press 9.25.09 The amusement park is a popular place at the Durham fair for the younger crowd. Show MoreShow Less
DURHAM >> Back a generation ago, when public singing transformed music class into a virtual hell for most pubescent-shy fifth-grade boys, there lived a boy named Tom Gimbel.
Gimbel, unlike most 10- or 11-year-old boys, wasn't afraid to sing in front of others, even the music teacher, who hovered over her students like a frosty stepmother. Gimbel had a pretty good voice, after all. Heck, he was almost a natural.
Before one particular class, Gimbel summoned his pals — other fearless high-voiced singers. "Let's freak the teacher and really go for it," he told them. So when the teacher rolled out her piano, as she always did to signal the start of class, and began to sing — those boys did just what Gimbel said. They went for it.
"You should have seen the expression on her face," Gimbel remembered recently. "It was one of sheer shock and pure joy!"
Today, many years later, that same bold fifth-grader who loved to sing before an audience plays guitar, flute and saxophone for the iconic rock band Foreigner.
That was then. Today, students are less wary of raising their voices in a public setting. Just ask Erin Schilling, choral teacher at Coginchaug Regional High School in Durham. Schilling's choir is, well, something special. "We are lucky with kids so talented who want to be in a music program. They are dedicated students," said Schilling.
So special, in fact, that a 28-member select choir will join that same bold singer from yesteryear's music class, Tom Gimbel, on stage. The Coginchaug choir will back up Foreigner when the multi-platinum-album-selling group performs its number one hit, "I Want to Know What Love Is," Saturday at the Durham Fair.
Schilling broke the news at the choir's first rehearsal of the new year. "The first night was when I told them and they all started jumping out of their seats with excitement," he said. "I encouraged them to go online and watch other choirs performing with Foreigner to get a sense of what it entails. They all came back the next day more excited. It was so cool."
Schilling said the students will assist Foreigner by selling CDs an hour before the concert and a half hour afterward. Each person that purchases a CD will receive a raffle ticket good for a chance to win a Les Paul guitar autographed by the band members. Monies raised will be donated to the band's charity partner, The Grammy Foundation, which works with groups like Foreigner to help keep music education curriculum available to students throughout North America. In addition, Foreigner will donate $500 to the choir for appearing.
"This opportunity for the school is a once-in-a-lifetime opportunity to share the stage with a band that has toured the world for so long," said Schilling, who was born in 1982, five years after the band was founded by Mick Jones and Lou Gramm. "I'm very familiar with their music. As soon as I was told, I got giddy myself and started playing all these songs. It was funny at first because I thought the kids wouldn't know all these songs because I'm younger and they are much younger. As soon as I said Foreigner and started practicing … all their songs they knew. I was really impressed with all they knew. They knew 'I Want to Know What Love is.'"
"That's wild that they knew the songs. That's every choir that shows up," said Gimbel. "There's a sheer joy in hearing kids who are not afraid to stand up and sing."
The select choir will also perform a set of eight or nine songs Thursday and Friday, including modern hits and songs of the 1970s and 1960s.
So how has the choir prepared for its five minutes (the actual length of "I Want to Know What Love Is") of stardom? Schilling said that because the choir will not have the opportunity to rehearse with the band prior to the concert, she and the choir have practiced by watching videos of other choirs performing.
"They told us which song we need to be waiting (to hear) backstage — probably 'Juke Box Hero,'" Schilling said. "Then they bring us on."
The Coginchaug choir will sing with a band that has sold over 80 million albums worldwide, nearly 40 million in the United States alone. The band was formed in 1976 when Brits Jones, Ian McDonald, and Dennis Elliott came together with Americans Gramm, Al Greenwood and Ed Gagliardi. Jones penned the name "Foreigner," in reference to the British/American merger.
Their race to stardom was swift. In 1977, the band released its first album, "Foreigner," which sold over 4 million copies and featured hits "Feels Like the First Time," "Cold as Ice" and "Long, Long Way from Home." With songs that featured Jones's catchy, driving guitar riffs, Gramm's angelic/thunderous voice, and outer-worldly keyboard parts from Al Greenwood, Foreigner quickly dominated both AM and FM airwaves. They went on to release five more albums that featured mega-hits such as "Double Vision," "Waiting for a Girl Like You," "Juke Box Hero" and, of course, "I Want to Know What Love Is."
But as successful as Foreigner was on the record racks and on stage, it struggled often in vain to maintain chemistry. Creative differences between band members have created a revolving door for personnel. Gramm, the voice of the band for 25 years, left the group for good in 2003.
Through all of the ups and downs, hits and flops, and changes in personnel, Jones has remained the face (and guitar) of the group. Between 2004 and 2005, he reformed the band, adding former Hurricane singer Kelley Hansen, Gimbel, bassist Jeff Pilson (formerly of Dokken), keyboardist Mike Bluestein, drummer Chris Frazier and guitarist Bruce Watson. In addition to touring regularly, the band recently released a three-disk CD, "Foreigner: Feels Like the First Time." Included is a DVD of the band in concert, a CD of remastered hits and a CD with acoustic versions of 11 songs.
Gimbel said the current lineup makes the band stronger than ever. "We have a phenomenal singer and frontman in Kelly Hansen, who interacts with the audience and gets them involved. He'll stop at nothing to get them on their feet. The audience is like the drummer — clapping becomes the drums."
Then there's Jones who, along with Gramm, was inducted into the Songwriters Hall of Fame in 2013.
Said Gimbel: "He's brilliant. I once asked Mick, 'How did you do it — write all those great songs?' He won't tell me."
The answer may be twofold: "The music itself is well-written and well-crafted. There are messages: (loves, angst) and people say, 'I know what that feels like. I've been waiting for a girl like you.' Everyone can relate to those feelings of longing — songs like 'Juke Box Hero' — it's for dreamers. These are fantastic stories we relate to."
Very soon, members of the Coginchaug select choir will know firsthand what it feels to sing with Foreigner ... for the first time.
Foreigner will perform Saturday at 7 p.m. on the Main Stage. The concert is free with a paid Durham Fair ticket. For information, visit durhamfair.com.


Today's sermon is entitled "Preparing a Banquet Table For Those That Aren't Hungry Yet". Click on the link below to listen through our website, or click here to download the sermon through iTunes. Also, click here to download the notes from today's sermon. As always, if you have a comment or question, be sure to leave it below or on one of our social media pages.


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Diagnostics;

namespace Pirate.PiVote.Kiosk
{
  public static class Program
  {
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    public static void Main()
    {
      Application.EnableVisualStyles();
      Application.SetCompatibleTextRenderingDefault(false);

      if (Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName + ".vshost").Count() > 0)
      {
        Application.Run(new KioskForm());
      }
      else
      {
        Application.Run(new ControlForm());
      }
    }
  }
}