From 6e21cbf23dd624e043500677e0cb83c8d6f354c4 Mon Sep 17 00:00:00 2001
From: Martin Williams <martinwork@users.noreply.github.com>
Date: Mon, 10 Jun 2024 15:59:18 +0100
Subject: [PATCH] Fetch MY_DATA

---
 app/src/main/AndroidManifest.xml              |    6 +
 .../com/samsung/microbit/ui/FetchPopups.java  |  113 ++
 .../java/com/samsung/microbit/ui/UIUtils.java |  274 +++++
 .../microbit/ui/activity/FetchActivity.java   | 1002 +++++++++++++++++
 .../microbit/ui/activity/PopUpActivity.java   |    3 +
 .../microbit/ui/activity/ProjectActivity.java |   33 +-
 .../com/samsung/microbit/utils/BLEFetch.java  |  622 ++++++++++
 .../microbit/utils/MicroBitUtility.java       |  229 ++++
 .../res/drawable-hdpi/ic_discover_black.png   |  Bin 0 -> 5215 bytes
 app/src/main/res/drawable-hdpi/ic_fetch.png   |  Bin 0 -> 6652 bytes
 .../main/res/drawable-hdpi/ic_more_vdotw.png  |  Bin 0 -> 334 bytes
 .../res/drawable-ldpi/ic_discover_black.png   |  Bin 0 -> 5045 bytes
 app/src/main/res/drawable-ldpi/ic_fetch.png   |  Bin 0 -> 4993 bytes
 .../main/res/drawable-ldpi/ic_more_vdotw.png  |  Bin 0 -> 269 bytes
 .../res/drawable-mdpi/ic_discover_black.png   |  Bin 0 -> 5045 bytes
 app/src/main/res/drawable-mdpi/ic_fetch.png   |  Bin 0 -> 4992 bytes
 .../main/res/drawable-mdpi/ic_more_vdotw.png  |  Bin 0 -> 269 bytes
 app/src/main/res/drawable-mdpi/v2only.png     |  Bin 0 -> 17713 bytes
 .../res/drawable-xhdpi/ic_discover_black.png  |  Bin 0 -> 5342 bytes
 app/src/main/res/drawable-xhdpi/ic_fetch.png  |  Bin 0 -> 5158 bytes
 .../main/res/drawable-xhdpi/ic_more_vdotw.png |  Bin 0 -> 424 bytes
 .../res/drawable-xxhdpi/ic_discover_black.png |  Bin 0 -> 5555 bytes
 app/src/main/res/drawable-xxhdpi/ic_fetch.png |  Bin 0 -> 7368 bytes
 .../res/drawable-xxhdpi/ic_more_vdotw.png     |  Bin 0 -> 630 bytes
 .../drawable-xxxhdpi/ic_discover_black.png    |  Bin 0 -> 5656 bytes
 .../main/res/drawable-xxxhdpi/ic_fetch.png    |  Bin 0 -> 6308 bytes
 .../res/drawable-xxxhdpi/ic_more_vdotw.png    |  Bin 0 -> 776 bytes
 .../main/res/drawable/fetch_select_gray.xml   |   10 +
 app/src/main/res/layout-land/fetch_select.xml |  255 +++++
 .../res/layout/custom_projects_button.xml     |   24 -
 app/src/main/res/layout/fetch_main.xml        |   15 +
 app/src/main/res/layout/fetch_select.xml      |  220 ++++
 app/src/main/res/layout/fetch_web.xml         |   64 ++
 app/src/main/res/layout/project_items.xml     |    1 -
 app/src/main/res/layout/projects_app_bar.xml  |   15 +-
 .../res/layout/view_projects_projects.xml     |   26 +-
 app/src/main/res/values-land/dimens.xml       |    8 +-
 .../main/res/values-sw360dp-land/dimens.xml   |    2 +
 .../main/res/values-sw360dp-port/dimens.xml   |    2 +
 .../main/res/values-sw600dp-land/dimens.xml   |    6 +-
 .../main/res/values-sw600dp-port/dimens.xml   |    4 +
 .../main/res/values-sw720dp-land/dimens.xml   |    2 +
 .../main/res/values-sw720dp-port/dimens.xml   |    2 +
 app/src/main/res/values/colors.xml            |    1 +
 app/src/main/res/values/dimens.xml            |    9 +-
 app/src/main/res/values/strings.xml           |   24 +-
 app/src/main/res/values/styles.xml            |    7 +
 47 files changed, 2931 insertions(+), 48 deletions(-)
 create mode 100644 app/src/main/java/com/samsung/microbit/ui/FetchPopups.java
 create mode 100644 app/src/main/java/com/samsung/microbit/ui/UIUtils.java
 create mode 100644 app/src/main/java/com/samsung/microbit/ui/activity/FetchActivity.java
 create mode 100644 app/src/main/java/com/samsung/microbit/utils/BLEFetch.java
 create mode 100644 app/src/main/java/com/samsung/microbit/utils/MicroBitUtility.java
 create mode 100644 app/src/main/res/drawable-hdpi/ic_discover_black.png
 create mode 100644 app/src/main/res/drawable-hdpi/ic_fetch.png
 create mode 100644 app/src/main/res/drawable-hdpi/ic_more_vdotw.png
 create mode 100644 app/src/main/res/drawable-ldpi/ic_discover_black.png
 create mode 100644 app/src/main/res/drawable-ldpi/ic_fetch.png
 create mode 100644 app/src/main/res/drawable-ldpi/ic_more_vdotw.png
 create mode 100644 app/src/main/res/drawable-mdpi/ic_discover_black.png
 create mode 100644 app/src/main/res/drawable-mdpi/ic_fetch.png
 create mode 100644 app/src/main/res/drawable-mdpi/ic_more_vdotw.png
 create mode 100644 app/src/main/res/drawable-mdpi/v2only.png
 create mode 100644 app/src/main/res/drawable-xhdpi/ic_discover_black.png
 create mode 100644 app/src/main/res/drawable-xhdpi/ic_fetch.png
 create mode 100644 app/src/main/res/drawable-xhdpi/ic_more_vdotw.png
 create mode 100644 app/src/main/res/drawable-xxhdpi/ic_discover_black.png
 create mode 100644 app/src/main/res/drawable-xxhdpi/ic_fetch.png
 create mode 100644 app/src/main/res/drawable-xxhdpi/ic_more_vdotw.png
 create mode 100644 app/src/main/res/drawable-xxxhdpi/ic_discover_black.png
 create mode 100644 app/src/main/res/drawable-xxxhdpi/ic_fetch.png
 create mode 100644 app/src/main/res/drawable-xxxhdpi/ic_more_vdotw.png
 create mode 100644 app/src/main/res/drawable/fetch_select_gray.xml
 create mode 100644 app/src/main/res/layout-land/fetch_select.xml
 delete mode 100644 app/src/main/res/layout/custom_projects_button.xml
 create mode 100644 app/src/main/res/layout/fetch_main.xml
 create mode 100644 app/src/main/res/layout/fetch_select.xml
 create mode 100644 app/src/main/res/layout/fetch_web.xml

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 514d5085..a7fe46a7 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -159,6 +159,12 @@
             android:label="MakeCode Webview"
             android:launchMode="singleTask"
             android:theme="@android:style/Theme.NoTitleBar.Fullscreen"/>
+        <activity
+            android:name=".ui.activity.FetchActivity"
+            android:configChanges="orientation|screenSize"
+            android:label="Fetch MY_DATA"
+            android:launchMode="singleTask"/>
+
         <service
             android:name=".service.DfuService"
             android:enabled="true"/>
diff --git a/app/src/main/java/com/samsung/microbit/ui/FetchPopups.java b/app/src/main/java/com/samsung/microbit/ui/FetchPopups.java
new file mode 100644
index 00000000..03b06496
--- /dev/null
+++ b/app/src/main/java/com/samsung/microbit/ui/FetchPopups.java
@@ -0,0 +1,113 @@
+package com.samsung.microbit.ui;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.View;
+import com.samsung.microbit.R;
+
+import static com.samsung.microbit.BuildConfig.DEBUG;
+
+public class FetchPopups {
+    private static final String TAG = FetchPopups.class.getSimpleName();
+
+    public void logi(String message) {
+        if(DEBUG) {
+            Log.i(TAG, "### " + Thread.currentThread().getId() + " # " + message);
+        }
+    }
+
+    /**
+     * Callback interface for client
+     */
+    public interface Client {
+        Context fetchPopupsContext();
+        void fetchPopupsCancelled();
+        void fetchPopupsRequestBluetoothConnectPermissions();
+    }
+
+    Client mClient = null;
+
+    public FetchPopups ( Client client) {
+        mClient = client;
+    }
+
+    View.OnClickListener popupClickActivityCancelled = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            logi("popupClickActivityCancelled");
+            PopUp.hide();
+            mClient.fetchPopupsCancelled();
+        }
+    };
+
+    public void busy() {
+        // Another download session is in progress.xml
+        PopUp.show(mClient.fetchPopupsContext().getString(R.string.multple_flashing_session_msg),
+                "",
+                R.drawable.error_face, R.drawable.blue_btn,
+                PopUp.GIFF_ANIMATION_FLASH,
+                PopUp.TYPE_ALERT,
+                popupClickActivityCancelled, popupClickActivityCancelled);
+    }
+
+    public void bluetoothOff() {
+        PopUp.show(mClient.fetchPopupsContext().getString(R.string.bluetooth_off_cannot_continue), //message
+                "",
+                R.drawable.error_face, R.drawable.red_btn,
+                PopUp.GIFF_ANIMATION_ERROR,
+                PopUp.TYPE_ALERT,
+                popupClickActivityCancelled, popupClickActivityCancelled);
+    }
+
+    public void bluetoothConnectPermissionError() {
+        PopUp.show(mClient.fetchPopupsContext().getString(R.string.ble_permission_connect_error),
+                mClient.fetchPopupsContext().getString(R.string.permissions_needed_title),
+                R.drawable.error_face, R.drawable.red_btn,
+                PopUp.GIFF_ANIMATION_ERROR,
+                PopUp.TYPE_ALERT,
+                popupClickActivityCancelled, popupClickActivityCancelled);
+    }
+
+    public void bluetoothConnectRequest() {
+        PopUp.show(mClient.fetchPopupsContext().getString(R.string.ble_permission_connect),
+                mClient.fetchPopupsContext().getString(R.string.permissions_needed_title),
+                R.drawable.message_face, R.drawable.blue_btn, PopUp.GIFF_ANIMATION_NONE,
+                PopUp.TYPE_CHOICE,
+                new View.OnClickListener() {
+                    @Override
+                    public void onClick(View v) {
+                        logi("bluetoothPermissionOKHandler");
+                        PopUp.hide();
+                        mClient.fetchPopupsRequestBluetoothConnectPermissions();
+                    }
+                },
+                new View.OnClickListener() {
+                    @Override
+                    public void onClick(View v) {
+                        logi("bluetoothPermissionCancelHandler");
+                        PopUp.hide();
+                        bluetoothConnectPermissionError();
+                    }
+                });
+    }
+
+    public void fetchFailed( String message) {
+        PopUp.show( message,
+                mClient.fetchPopupsContext().getString(R.string.fetchFailed),
+                R.drawable.error_face, R.drawable.red_btn,
+                PopUp.GIFF_ANIMATION_ERROR,
+                PopUp.TYPE_ALERT,
+                popupClickActivityCancelled, popupClickActivityCancelled);
+    }
+
+    public void fetchProgress() {
+        PopUp.show("",
+                mClient.fetchPopupsContext().getString(R.string.fetching),
+                R.drawable.flash_face,
+                R.drawable.blue_btn,
+                PopUp.GIFF_ANIMATION_FLASH,
+                PopUp.TYPE_PROGRESS,
+                popupClickActivityCancelled, popupClickActivityCancelled);
+    }
+
+}
diff --git a/app/src/main/java/com/samsung/microbit/ui/UIUtils.java b/app/src/main/java/com/samsung/microbit/ui/UIUtils.java
new file mode 100644
index 00000000..a85a129b
--- /dev/null
+++ b/app/src/main/java/com/samsung/microbit/ui/UIUtils.java
@@ -0,0 +1,274 @@
+package com.samsung.microbit.ui;
+
+import android.app.Activity;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import android.util.Log;
+import android.util.TypedValue;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowMetrics;
+import android.widget.Button;
+import android.widget.ImageButton;
+import android.widget.TextView;
+
+import com.samsung.microbit.R;
+
+import static com.samsung.microbit.BuildConfig.DEBUG;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.IdRes;
+
+import pl.droidsonroids.gif.GifDrawable;
+import pl.droidsonroids.gif.GifImageView;
+
+public class UIUtils {
+    private static final String TAG = UIUtils.class.getSimpleName();
+
+    public void logi(String message) {
+        if(DEBUG) {
+            Log.i(TAG, "### " + Thread.currentThread().getId() + " # " + message);
+        }
+    }
+
+    /**
+     * Callback interface for client
+     */
+    public interface Client {
+        Activity uiUtilsActivity();
+    }
+
+    Client mClient = null;
+
+    public UIUtils ( Client client) {
+        mClient = client;
+    }
+
+    @NonNull
+    public Point displayWindowSize() {
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+            WindowMetrics wm = null;
+            wm = mClient.uiUtilsActivity().getWindowManager().getCurrentWindowMetrics();
+            Rect r = wm.getBounds();
+            return new Point( r.width(), r.height());
+        }
+        Point s = new Point();
+        mClient.uiUtilsActivity().getWindowManager().getDefaultDisplay().getSize(s);
+        return s;
+    }
+
+    public float labelFontSize()
+    {
+        Point s = displayWindowSize();
+
+        float fh;
+        float fw;
+        if ( s.y > s.x) // portrait
+        {
+            fh = (float) (12 * s.y) / 480;
+            fw = (float) (12 * s.x) / 320;
+        }
+        else
+        {
+            fh = (float) (12 * s.y) / 320;
+            fw = (float) (12 * s.x) / 480;
+        }
+        float f = Math.min(fw, fh);
+        logi( "displayLabelFontSize " + (double)f + ", " + (double)fw + ", " + (double)fh);
+        return f;
+    }
+
+
+    public float headerFontSize()
+    {
+        Point s = displayWindowSize();
+
+        float fh;
+        float fw;
+        if ( s.y > s.x) // portrait
+        {
+            fh = (float) (14 * s.y) / 480;
+            fw = (float) (14 * s.x) / 320;
+        }
+        else
+        {
+            fh = (float) (14 * s.y) / 320;
+            fw = (float) (14 * s.x) / 480;
+        }
+        float f = Math.min(fw, fh);
+        logi( "displayHeaderFontSize " + (double)f + ", " + (double)fw + ", " + (double)fh);
+        return f;
+    }
+
+
+    public float buttonFontSize()
+    {
+        Point s = displayWindowSize();
+
+        float fh;
+        float fw;
+        if ( s.y > s.x) // portrait
+        {
+            fh = (float) (10 * s.y) / 480;
+            fw = (float) (10 * s.x) / 320;
+        }
+        else
+        {
+            fh = (float) (10 * s.y) / 320;
+            fw = (float) (10 * s.x) / 480;
+        }
+        float f = Math.min(fw, fh);
+        logi( "displayButtonFontSize " + (double)f + ", " + (double)fw + ", " + (double)fh);
+        return f;
+    }
+
+    public float tinyButtonFontSize()
+    {
+        Point s = displayWindowSize();
+
+        float fh;
+        float fw;
+        if ( s.y > s.x) // portrait
+        {
+            fh = (float) (44 * s.y) / 1024;
+            fw = (float) (44 * s.x) / 768;
+        }
+        else
+        {
+            fh = (float) (44 * s.y) / 768;
+            fw = (float) (44 * s.x) / 1024;
+        }
+        float f = Math.min(fw, fh);
+        if ( f < 22) f = 22;
+        logi( "displayTinyButtonFontSize " + (double)f + ", " + (double)fw + ", " + (double)fh);
+        return f;
+    }
+
+    public void setTypeface( View view, Typeface typeface) {
+        if ( view != null) {
+            if ( view instanceof Button) {
+                logi( "Button " + ((Button) view).getText() + " = " + typeface.toString());
+                ((Button) view).setTypeface(typeface);
+            } else if ( view instanceof TextView) {
+                logi( "TextView " + ((TextView) view).getText() + " = " + typeface.toString());
+                ((TextView) view).setTypeface(typeface);
+            }
+        }
+    }
+
+    public void setFontSize( View view, float size) {
+        if ( view != null) {
+            if ( view instanceof Button) {
+                logi("Button " + ((Button) view).getText() + " = " + size);
+                ((Button) view).setTextSize( TypedValue.COMPLEX_UNIT_PX, size);
+            } else if ( view instanceof TextView) {
+                logi("TextView " + ((TextView) view).getText() + " = " + size);
+                ((TextView) view).setTextSize(TypedValue.COMPLEX_UNIT_PX, size);
+            }
+        }
+    }
+
+    @Nullable
+    public <T extends View> T findViewById(@IdRes int id) {
+        return mClient.uiUtilsActivity().findViewById(id);
+    }
+
+    public void setTypeface(@IdRes int id, Typeface typeface) {
+        setTypeface( findViewById(id), typeface);
+    }
+
+    public void setFontSize( @IdRes int id, float size) {
+        setFontSize( findViewById(id), size);
+    }
+
+    public void setTypefaces(ViewGroup parent, Typeface button, Typeface textview) {
+        Class<Button> buttonClass = Button.class;
+
+        logi("displaySetTypefaces");
+        int count = parent.getChildCount();
+        for ( int i = 0; i < count; i++) {
+            View view = parent.getChildAt(i);
+            if ( view instanceof Button) {
+                setTypeface( view, button);
+            } else if ( view instanceof TextView) {
+                setTypeface( view, textview);
+            } else if ( view instanceof ViewGroup) {
+                setTypefaces( (ViewGroup) view, button, textview);
+            }
+        }
+    }
+
+    public void setFontSizes( ViewGroup parent, float button, float textview) {
+        logi("displaySetFontSizes");
+        int count = parent.getChildCount();
+        for ( int i = 0; i < count; i++) {
+            View view = parent.getChildAt(i);
+            if ( view instanceof Button) {
+                setFontSize( view, button);
+            } else if ( view instanceof TextView) {
+                setFontSize( view, textview);
+            } else if ( view instanceof ViewGroup) {
+                setFontSizes( (ViewGroup) view, button, textview);
+            }
+        }
+    }
+
+    public void setButtonClicks( ViewGroup parent, View.OnClickListener onClickListener) {
+        logi("setButtonClicks");
+        int count = parent.getChildCount();
+        for ( int i = 0; i < count; i++) {
+            View view = parent.getChildAt(i);
+            if ( view instanceof ImageButton) {
+                logi("ImageButton");
+                view.setOnClickListener( onClickListener);
+            } else if ( view instanceof Button) {
+                logi("Button " + ((Button) view).getText());
+                view.setOnClickListener( onClickListener);
+            } else if ( view instanceof ViewGroup) {
+                setButtonClicks( (ViewGroup) view, onClickListener);
+            }
+        }
+    }
+
+    public void setVisibility( @IdRes int id, int visibility) {
+        View view = findViewById(id);
+        if ( view != null) {
+            view.setVisibility(visibility);
+        }
+    }
+
+    public void setVisible( @IdRes int id, boolean show) {
+        View view = findViewById(id);
+        if ( view != null) {
+            view.setVisibility( show ? View.VISIBLE : View.GONE);
+        }
+    }
+
+    public void setEnabled( @IdRes int id, boolean enabled) {
+        View view = findViewById(id);
+        if ( view != null) {
+            view.setEnabled( enabled);
+        }
+    }
+
+    public void setBackground( @IdRes int id, Drawable drawable) {
+        View view = findViewById(id);
+        if ( view != null) {
+            view.setBackground( drawable);
+        }
+    }
+
+    public void gifAnimate( @IdRes int id) {
+        View view = findViewById(id);
+        if ( view != null && view instanceof GifImageView) {
+            GifDrawable drawable = (GifDrawable) ((GifImageView)view).getDrawable();
+            if ( drawable != null) {
+                drawable.reset();
+            }
+            view.animate();
+        }
+    }
+}
diff --git a/app/src/main/java/com/samsung/microbit/ui/activity/FetchActivity.java b/app/src/main/java/com/samsung/microbit/ui/activity/FetchActivity.java
new file mode 100644
index 00000000..82c67ef6
--- /dev/null
+++ b/app/src/main/java/com/samsung/microbit/ui/activity/FetchActivity.java
@@ -0,0 +1,1002 @@
+package com.samsung.microbit.ui.activity;
+
+import static com.samsung.microbit.BuildConfig.DEBUG;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.SpannableString;
+import android.text.SpannableStringBuilder;
+import android.text.Spanned;
+import android.text.style.BulletSpan;
+import android.util.Base64;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.webkit.DownloadListener;
+import android.webkit.JavascriptInterface;
+import android.webkit.ValueCallback;
+import android.webkit.WebChromeClient;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import androidx.activity.OnBackPressedCallback;
+import androidx.annotation.NonNull;
+import androidx.appcompat.content.res.AppCompatResources;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import androidx.core.content.PermissionChecker;
+
+import com.samsung.microbit.MBApp;
+import com.samsung.microbit.R;
+import com.samsung.microbit.core.bluetooth.BluetoothUtils;
+import com.samsung.microbit.data.constants.PermissionCodes;
+import com.samsung.microbit.data.constants.RequestCodes;
+import com.samsung.microbit.ui.BluetoothChecker;
+import com.samsung.microbit.ui.FetchPopups;
+import com.samsung.microbit.ui.PopUp;
+import com.samsung.microbit.ui.UIUtils;
+import com.samsung.microbit.ui.view.PatternDrawable;
+import com.samsung.microbit.utils.BLEFetch;
+import com.samsung.microbit.utils.FileUtils;
+
+import java.io.File;
+import java.nio.ByteBuffer;
+
+/**
+ * Represents the Flash screen that contains a list of project samples
+ * and allows to flash them to a micro:bit or remove them from the list.
+ */
+public class FetchActivity extends Activity implements View.OnClickListener, UIUtils.Client, FetchPopups.Client, BLEFetch.Client {
+    private static final String TAG = FetchActivity.class.getSimpleName();
+
+    public void logi(String message) {
+        if (DEBUG) {
+            Log.i(TAG, "### " + Thread.currentThread().getId() + " # " + message);
+        }
+    }
+
+    private static final int FETCH_REQUEST_CODE_EXPORT = 1;
+    private static final int FETCH_REQUEST_CODE_IMPORT = 2;
+    private static final int FETCH_REQUEST_CODE_RESET_TO_BLE = 3;
+    private static final int FETCH_REQUEST_CODE_PAIR = 4;
+    private static final int FETCH_REQUEST_CODE_PAIR_ALREADY_RESET = 5;
+
+    enum ePurpose {
+        None,
+        Select,
+        Check,
+        Pair,
+        Fetch,
+        Connect,
+        Data,
+        Error
+    }
+
+    enum eFetchChoice {
+        After,
+        During
+    }
+
+    ePurpose mPurpose = ePurpose.Select;
+    eFetchChoice mFetchChoice = eFetchChoice.After;
+    boolean pairSuccess = false;
+
+    private WebView mWebView;
+    private FetchWebJS mWebJavascriptInterface = null;
+
+    private static final int REQUEST_CODE_SAVEDATA = 1;
+    private static final int REQUEST_CODE_CHOOSE_FILE = 2;
+    private static final int REQUEST_CODE_FLASH = 3;
+    private byte[] dataToSave = null;
+    private ValueCallback<Uri[]> mWebFileChooserCallback;
+
+    /**
+     * Helper - UIUtils
+     */
+
+    UIUtils mui = new UIUtils(this);
+
+    @Override
+    public Activity uiUtilsActivity() {
+        return this;
+    }
+
+    /**
+     * Helper - FetchPopups
+     */
+
+    FetchPopups mPopups = new FetchPopups(this);
+
+    @Override
+    public Context fetchPopupsContext() {
+        return this;
+    }
+
+    @Override
+    public void fetchPopupsCancelled() {
+        activityCancelled();
+    }
+
+    @Override
+    public void fetchPopupsRequestBluetoothConnectPermissions() {
+        requestPermissions();
+    }
+
+    /**
+     * Helper - BLEFetch
+     */
+
+    private BLEFetch mFetch = new BLEFetch(this);
+
+    @Override
+    public Activity bleFetchGetActivity() {
+        return this;
+    }
+
+    @Override
+    public String bleFetchGetDeviceAddress() {
+        return BluetoothUtils.getCurrentMicrobit(this).mAddress;
+    }
+
+    @Override
+    public void bleFetchProgress(float progress) {
+        PopUp.updateProgressBar((int) (progress * 100));
+    }
+
+    @Override
+    public void bleFetchState() {
+        switch (mFetch.resultState) {
+            case None:
+            case Found:
+            case Connected:
+                break;
+            case Discovered:
+                mPopups.fetchProgress();
+                break;
+            case ConnectTimeout:
+                PopUp.hide();
+                purposeError(getString(R.string.fetch_connection_failed));
+                break;
+            case WorkTimeout:
+                PopUp.hide();
+                purposeError(getString(R.string.fetch_connection_lost));
+                break;
+            case Error:
+                PopUp.hide();
+                switch (mFetch.mWorkResult) {
+                    case BleError:
+                        purposeError(getString(R.string.fetch_connection_broken));
+                        break;
+                    case V2Only:
+                        purposeError(getString(R.string.fetch_works_with_micro_bit_v2_only));
+                        break;
+                    case NoService:
+                        purposeError(getString(R.string.fetch_update_the_project_to_add_the_bluetooth_service));
+                        break;
+                    case Protocol:
+                        purposeError(getString(R.string.fetch_connection_error));
+                        break;
+                    case NoData:
+                        purposeError(getString(R.string.fetch_no_data_in_micro_bit));
+                        break;
+                    case OutOfMemory:
+                        purposeError(getString(R.string.fetch_out_of_memory));
+                        break;
+                }
+                break;
+            case Success:
+                PopUp.hide();
+                purposeData();
+                break;
+        }
+    }
+
+    /**
+     * Activity overrides
+     */
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        logi("onCreate");
+        super.onCreate(savedInstanceState);
+
+        displayCreate();
+
+        purposeStart();
+    }
+
+    @Override
+    public void onConfigurationChanged(@NonNull Configuration newConfig) {
+        logi("onConfigurationChanged");
+        super.onConfigurationChanged(newConfig);
+        displayConfigurationChanged(newConfig);
+    }
+
+    @Override
+    protected void onDestroy() {
+        logi("onDestroy");
+        super.onDestroy();
+        displayDestroy();
+    }
+
+    @Override
+    protected void onStart() {
+        logi("onStart");
+        super.onStart();
+    }
+
+    @Override
+    protected void onStop() {
+        logi("onStop");
+        super.onStop();
+    }
+
+    @Override
+    protected void onResume() {
+        logi("onResume");
+        super.onResume();
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        purposeStart();
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        switch (requestCode) {
+            case FETCH_REQUEST_CODE_RESET_TO_BLE:
+                if (resultCode == RESULT_OK) {
+                    switch (MBApp.getAppState().pairState()) {
+                        case PairStateNone:
+                        case PairStateError:
+                            activityCancelled();
+                            break;
+                        case PairStateLaunch:
+                        case PairStateSession:
+                            purposeCheck();
+                            break;
+                        case PairStateChecked:
+                        default:
+                            purposeConnect();
+                            break;
+                    }
+                } else {
+                    activityCancelled();
+                }
+                break;
+
+            case FETCH_REQUEST_CODE_PAIR:
+            case FETCH_REQUEST_CODE_PAIR_ALREADY_RESET:
+                if (resultCode == RESULT_OK) {
+                    connectWithChecksAfterPairing();
+                } else {
+                    activityCancelled();
+                }
+                break;
+
+            case RequestCodes.REQUEST_ENABLE_BT:
+                if (resultCode == RESULT_OK) {
+                    connectWithChecksAfterBlePermissionGrantedAndBleEnabled();
+                } else if (resultCode == Activity.RESULT_CANCELED) {
+                    mPopups.bluetoothOff();
+                }
+                break;
+            case REQUEST_CODE_SAVEDATA:
+                if (resultCode != RESULT_OK) {
+                    dataToSave = null;
+                    return;
+                }
+                if (dataToSave != null && dataToSave.length > 0) {
+                    Uri uri = data.getData();
+                    if (!FileUtils.writeBytesToUri(uri, dataToSave, this)) {
+                        Toast.makeText(this, "Could not save file", Toast.LENGTH_LONG).show();
+                    }
+                }
+                dataToSave = null;
+                break;
+        }
+    }
+
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[],
+                                           @NonNull int[] grantResults) {
+        requestPermissionsResult(requestCode, permissions, grantResults);
+    }
+
+    /**
+     * Calling other activities
+     */
+
+    boolean activityIsBusy() {
+        return false;
+    }
+
+    void activityCancelled() {
+        setResult(RESULT_CANCELED);
+        finish();
+    }
+
+    private void activityComplete() {
+        setResult(RESULT_OK);
+        finish();
+    }
+
+    void activityRestart() {
+    }
+
+    private void goToPairingToPair() {
+        Intent i = new Intent(this, PairingActivity.class);
+        i.setAction(PairingActivity.ACTION_PAIR_BEFORE_FLASH);
+        startActivityForResult(i, FETCH_REQUEST_CODE_PAIR);
+    }
+
+    private void goToPairingToPairAlreadyReset() {
+        Intent i = new Intent(this, PairingActivity.class);
+        i.setAction(PairingActivity.ACTION_PAIR_BEFORE_FLASH_ALREADY_RESET);
+        startActivityForResult(i, FETCH_REQUEST_CODE_PAIR_ALREADY_RESET);
+    }
+
+    private void goToPairingResetToBLE() {
+        Intent i = new Intent(this, PairingActivity.class);
+        i.setAction(PairingActivity.ACTION_RESET_TO_BLE);
+        startActivityForResult(i, FETCH_REQUEST_CODE_RESET_TO_BLE);
+    }
+
+    private void pairBeforeFlashFinish(int resultCode) {
+        setResult(resultCode);
+        finish();
+    }
+
+    /**
+     * Clicks
+     */
+
+    @Override
+    public void onBackPressed() {
+        if ( mPurpose == ePurpose.Data) {
+            displayHtmlGoBack();
+        } else {
+            activityCancelled();
+        }
+    }
+
+    @Override
+    public void onClick(final View v) {
+        switch (v.getId()) {
+            case R.id.fetchWebBarBack:
+                onBackPressed();
+                break;
+
+            case R.id.fetchSelectChoiceAfter:
+                mFetchChoice = eFetchChoice.After;
+                displayUpdateControls();
+                break;
+
+            case R.id.fetchSelectChoiceDuring:
+                mFetchChoice = eFetchChoice.During;
+                displayUpdateControls();
+                break;
+
+            case R.id.fetchSelectOK:
+                onClickSelectOK();
+                break;
+
+            case R.id.fetchSelectCancel:
+            case R.id.viewProjectsPatternCancel:
+                activityCancelled();
+                break;
+
+            case R.id.viewProjectsPatternDifferent:
+            case R.id.viewProjectsSearchingDifferent:
+                MBApp.getAppState().eventPairDifferent();
+                displayShowSearchingDifferent(false);
+                purposePairWithoutReset();
+                break;
+
+            case R.id.viewProjectsPatternOK:
+                MBApp.getAppState().eventPairChecked();
+                purposeFetch();
+                break;
+
+            case R.id.fetchSelectDuringMore:
+                Intent intent = new Intent(Intent.ACTION_VIEW);
+                intent.setData(Uri.parse(getString(R.string.fetchDuringFindOutMoreUrl)));
+                startActivity(intent);
+                break;
+        }
+    }
+
+    private void onClickSelectOK() {
+        if (mFetchChoice == eFetchChoice.During) {
+            if (canFetchNoReset()) {
+                purposeConnect();
+            }
+            // button should be disabled otherwise
+            return;
+        }
+
+        switch (MBApp.getAppState().pairState()) {
+            case PairStateNone:
+            case PairStateError:
+                purposePairWithoutReset();
+                break;
+            case PairStateLaunch:
+            case PairStateSession:
+                purposeCheck();
+                break;
+            case PairStateChecked:
+            default:
+                purposeFetch();
+                break;
+        }
+    }
+
+    private boolean canFetchNoReset() {
+        boolean can = true;
+
+        switch (MBApp.getAppState().pairState()) {
+            case PairStateNone:
+            case PairStateError:
+                can = false;
+                break;
+            case PairStateLaunch:
+            case PairStateSession:
+            case PairStateChecked:
+            default:
+                break;
+        }
+
+        return can;
+    }
+
+    /**
+     * Activity modes
+     */
+
+    private void purposeStart() {
+        if (activityIsBusy()) {
+            mPopups.busy();
+            return;
+        }
+        purposeSelect();
+    }
+
+
+    private void purposeSelect() {
+        logi("purposeSelect");
+        mPurpose = ePurpose.Select;
+        mFetch.fetchCancel();
+        displayUpdateControls();
+    }
+
+    private void purposePairWithReset() {
+        logi("purposePairWithReset");
+        mPurpose = ePurpose.Pair;
+        mFetch.fetchCancel();
+        displayUpdateControls();
+        goToPairingToPair();
+    }
+
+    private void purposePairWithoutReset() {
+        logi("purposePairWithoutReset");
+        mPurpose = ePurpose.Pair;
+        mFetch.fetchCancel();
+        displayUpdateControls();
+        goToPairingToPairAlreadyReset();
+    }
+
+    private void purposeCheck() {
+        logi("purposeCheck");
+        mPurpose = ePurpose.Check;
+        mFetch.fetchCancel();
+        displayUpdateControls();
+    }
+
+    private void purposeFetch() {
+        logi("purposeFetch");
+        mPurpose = ePurpose.Fetch;
+        displayUpdateControls();
+        connectWithChecks();
+    }
+
+    private void purposeConnect() {
+        logi("purposeConnect");
+        mPurpose = ePurpose.Connect;
+        displayUpdateControls();
+        mFetch.fetchStart();
+    }
+
+    private void purposeData() {
+        logi("purposeData");
+
+        mFetch.fetchCancel();
+
+        if ( displayHtmlSave( mFetch.fetchData())) {
+            mPurpose = ePurpose.Data;
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    displayHtmlLoad();
+                    displayUpdateControls();
+                }
+            });
+        } else {
+            purposeError(getString(R.string.fetch_failed_to_create_my_data_htm));
+        }
+    }
+
+    private void purposeError(String message) {
+        logi("purposeError");
+        MBApp.getAppState().eventPairSendError();
+        mPurpose = ePurpose.Error;
+        mPopups.fetchFailed(message);
+    }
+
+    /**
+     * Connect with checks for permissions, BLE enabled etc.
+     */
+
+    private boolean connectWithChecks() {
+        Log.v(TAG, "connectWithChecks");
+
+        if (activityIsBusy()) {
+            mPopups.busy();
+            return false;
+        }
+
+        if (havePermissions()) {
+            if (BluetoothChecker.getInstance().isBluetoothON()) {
+                connectWithChecksAfterBlePermissionGrantedAndBleEnabled();
+                return true;
+            }
+            enableBluetooth();
+        } else {
+            mPopups.bluetoothConnectRequest();
+        }
+        return false;
+    }
+
+    private void connectWithChecksAfterBlePermissionGranted() {
+        if (!BluetoothChecker.getInstance().isBluetoothON()) {
+            enableBluetooth();
+            return;
+        }
+        connectWithChecksAfterBlePermissionGrantedAndBleEnabled();
+    }
+
+    private void connectWithChecksAfterBlePermissionGrantedAndBleEnabled() {
+
+        switch (MBApp.getAppState().pairState()) {
+            case PairStateNone:
+            case PairStateError:
+                //showPopupQuestionFlashToDevice( true);
+                purposePairWithoutReset();
+                break;
+            case PairStateLaunch:
+            case PairStateSession:
+                purposeCheck();
+                break;
+            case PairStateChecked:
+                purposeConnect();
+                break;
+            default:
+                purposePairWithoutReset();
+                break;
+        }
+    }
+
+    private void connectWithChecksAfterPairing() {
+        goToPairingResetToBLE();
+    }
+
+    /**
+     * Permissions, enable BLE, etc.
+     */
+
+    @SuppressLint("MissingPermission")
+    private void enableBluetooth() {
+        Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
+        startActivityForResult(enableBtIntent, RequestCodes.REQUEST_ENABLE_BT);
+    }
+
+    private boolean havePermission(String permission) {
+        return ContextCompat.checkSelfPermission(this, permission) == PermissionChecker.PERMISSION_GRANTED;
+    }
+
+    private boolean havePermissions() {
+        boolean yes = true;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            if (!havePermission(Manifest.permission.BLUETOOTH_CONNECT))
+                yes = false;
+        }
+        return yes;
+    }
+
+    private void requestPermission(String[] permissions, final int requestCode) {
+        ActivityCompat.requestPermissions(this, permissions, requestCode);
+    }
+
+    private void requestPermissions() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            String[] permissionsNeeded = {
+                    Manifest.permission.BLUETOOTH_CONNECT};
+            requestPermission(permissionsNeeded, PermissionCodes.BLUETOOTH_PERMISSIONS_REQUESTED_FLASHING_API31);
+        }
+    }
+
+    private void requestPermissionsResult(int requestCode,
+                                          @NonNull String permissions[],
+                                          @NonNull int[] grantResults) {
+        if (havePermissions()) {
+            connectWithChecksAfterBlePermissionGranted();
+            return;
+        }
+
+        switch (requestCode) {
+            case PermissionCodes.BLUETOOTH_PERMISSIONS_REQUESTED_FLASHING_API31: {
+                mPopups.bluetoothConnectPermissionError();
+                break;
+            }
+        }
+    }
+
+    /**
+     * Display
+     */
+
+    private void displayCreate() {
+        //Remove title bar
+        this.requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(R.layout.fetch_main);
+        displayHtmlDelete();
+        displayInit();
+    }
+
+    public void displayConfigurationChanged(Configuration newConfig) {
+        setContentView(R.layout.fetch_main);
+        displayInit();
+    }
+
+    private void displayDestroy() {
+        displayHtmlDelete();
+    }
+
+    private void displayInit() {
+        displayHtmlInit();
+        displayUpdate();
+    }
+
+    private void displayUpdate() {
+        displayUpdateControls();
+        displayFonts();
+    }
+
+    private void displayFonts() {
+        MBApp application = MBApp.getApp();
+        Typeface textTypeface = application.getTypeface();
+        Typeface buttonTypeface = application.getRobotoTypeface();
+
+        ViewGroup parent = findViewById(R.id.fetchMain);
+        mui.setTypefaces(parent, buttonTypeface, textTypeface);
+        mui.setFontSizes(parent, mui.buttonFontSize(), mui.labelFontSize());
+
+        mui.setButtonClicks(parent, this);
+
+        Typeface headerTypeface = MBApp.getApp().getTypefaceBold();
+        float headerFontSize = mui.headerFontSize();
+
+        mui.setTypeface(R.id.fetchSelectTitle, headerTypeface);
+        mui.setTypeface(R.id.fetchSelectAfterTitle, headerTypeface);
+        mui.setTypeface(R.id.viewProjectsPatternHeader, headerTypeface);
+        mui.setTypeface(R.id.viewProjectsSearchingHeader, headerTypeface);
+
+        mui.setFontSize(R.id.fetchSelectTitle, headerFontSize);
+        mui.setFontSize(R.id.fetchSelectAfterTitle, headerFontSize);
+        mui.setFontSize(R.id.viewProjectsPatternHeader, headerFontSize);
+        mui.setFontSize(R.id.viewProjectsSearchingHeader, headerFontSize);
+
+        displayShowSearchingDifferent(true);
+    }
+
+    private void displayShowSearchingDifferent(boolean show) {
+        mui.setVisibility(R.id.viewProjectsSearchingDifferent, show ? View.VISIBLE : View.INVISIBLE);
+    }
+
+    private void displaySetDuringText() {
+        MBApp application = MBApp.getApp();
+        Typeface textTypeface = application.getTypeface();
+        TextView textView = (TextView) findViewById(R.id.fetchSelectDuringText);
+        if (textView == null) {
+            return;
+        }
+        SpannableString text0 = new SpannableString(getString(R.string.fetchSelectDuring0));
+        SpannableString text1 = new SpannableString(getString(R.string.fetchSelectDuring1));
+        SpannableString text2 = new SpannableString(getString(R.string.fetchSelectDuring2));
+        SpannableString nl = new SpannableString("\n");
+
+        text1.setSpan(new BulletSpan(), 0, text1.length(), Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
+        text2.setSpan(new BulletSpan(), 0, text2.length(), Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
+
+        SpannableStringBuilder ss = new SpannableStringBuilder(text0);
+        ss.append(nl);
+        ss.append(nl);
+        ss.append(text1);
+        ss.append(nl);
+        ss.append(nl);
+        ss.append(text2);
+        ss.append(nl);
+        textView.setText(ss);
+    }
+
+    private void displayUpdateControls() {
+        displaySetDuringText();
+        displayUpdateDeviceName();
+
+        boolean web = mPurpose == ePurpose.Data;
+        boolean select = mPurpose == ePurpose.Select || mPurpose == ePurpose.Fetch || mPurpose == ePurpose.None;
+        boolean pattern = mPurpose == ePurpose.Check;
+        boolean searching = mPurpose == ePurpose.Connect;
+
+        mui.setVisible(R.id.fetchWeb, web);
+        mui.setVisible(R.id.fetchSelect, select);
+        mui.setVisible(R.id.viewProjectsPattern, pattern);
+        mui.setVisible(R.id.viewProjectsSearching, searching);
+
+        mui.setEnabled(R.id.fetchSelectOK, mFetchChoice == eFetchChoice.After || canFetchNoReset());
+
+        Drawable yes = AppCompatResources.getDrawable(this, R.drawable.white_btn);
+        Drawable no = AppCompatResources.getDrawable(this, R.drawable.fetch_select_gray);
+        switch (mFetchChoice) {
+            case After:
+                mui.setBackground(R.id.fetchSelectChoiceAfter, yes);
+                mui.setBackground(R.id.fetchSelectChoiceDuring, no);
+                mui.gifAnimate(R.id.fetchSelectAfterGif);
+                mui.setVisible(R.id.fetchSelectAfter, true);
+                mui.setVisible(R.id.fetchSelectDuring, false);
+                break;
+            case During:
+                mui.setBackground(R.id.fetchSelectChoiceAfter, no);
+                mui.setBackground(R.id.fetchSelectChoiceDuring, yes);
+                mui.setVisible(R.id.fetchSelectDuring, true);
+                mui.setVisible(R.id.fetchSelectAfter, false);
+                break;
+        }
+    }
+
+    private void displayUpdateDeviceName() {
+        String deviceName = "     ";
+        if (havePermissions()) {
+            String pattern = BluetoothUtils.getCurrentMicrobit(this).mPattern;
+            if (pattern != null) {
+                deviceName = pattern;
+            }
+        }
+
+        PatternDrawable patternDrawable = new PatternDrawable();
+        ImageView patternGrid = (ImageView) findViewById(R.id.viewProjectsPatternGrid);
+        TextView patternHeader = (TextView) findViewById(R.id.viewProjectsPatternHeader);
+        patternGrid.setImageDrawable(patternDrawable);
+        String headerText = getResources().getString(R.string.compare_your_pattern_with_NAME, deviceName);
+        patternHeader.setText(headerText);
+        patternDrawable.setDeviceName(deviceName);
+
+        PatternDrawable searchDrawable = new PatternDrawable();
+        ImageView searchGrid = (ImageView) findViewById(R.id.viewProjectsSearchingGrid);
+        TextView searchHeader = (TextView) findViewById(R.id.viewProjectsSearchingHeader);
+        searchGrid.setImageDrawable(searchDrawable);
+
+        String searchText = getResources().getString(R.string.searching_for_microbit_NAME, deviceName);
+        searchHeader.setText(searchText);
+        searchDrawable.setDeviceName(deviceName);
+    }
+
+    /**
+     * Display WebView
+     */
+
+    private void displayHtmlInit() {
+        mWebView = findViewById(R.id.fetchWebView);
+        if (mWebView == null) {
+            return;
+        }
+
+        mWebView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+
+        WebSettings webSettings = mWebView.getSettings();
+        webSettings.setJavaScriptCanOpenWindowsAutomatically(true);
+        webSettings.setJavaScriptEnabled(true);
+        webSettings.setUseWideViewPort(true);
+        webSettings.setLoadWithOverviewMode(true);
+        webSettings.setBuiltInZoomControls(true);
+        webSettings.setDisplayZoomControls(false);
+        webSettings.setDomStorageEnabled(true);
+        webSettings.setAllowFileAccess(true);
+        webSettings.setAllowContentAccess(true);
+        WebView.setWebContentsDebuggingEnabled(false);
+        mWebJavascriptInterface = new FetchWebJS(this);
+        mWebView.addJavascriptInterface(mWebJavascriptInterface, "AndroidFunction");
+
+        mWebView.setWebViewClient(new WebViewClient() {
+            @Override
+            public boolean shouldOverrideUrlLoading(WebView view, String url) {
+                Log.v(TAG, "shouldOverrideUrlLoading: " + url);
+                return false;
+            }
+
+            @Override
+            public void onLoadResource(WebView view, String url) {
+                super.onLoadResource(view, url);
+                Log.v(TAG, "onLoadResource(" + url + ");");
+            }
+
+            @Override
+            public void onPageFinished(WebView view, String url) {
+                super.onPageFinished(view, url);
+                Log.v(TAG, "onPageFinished(" + url + ");");
+                //onPageFinishedJS( view, url);
+            }
+        }); //setWebViewClient
+
+        mWebView.setWebChromeClient(new WebChromeClient() {
+            @Override
+            public boolean onShowFileChooser(WebView webView, ValueCallback<Uri[]> filePathCallback, WebChromeClient.FileChooserParams fileChooserParams) {
+                mWebFileChooserCallback = filePathCallback;
+                try {
+                    Intent intent = fileChooserParams.createIntent();
+                    startActivityForResult(intent, REQUEST_CODE_CHOOSE_FILE);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    return false;
+                }
+                return true;
+
+            }
+        }); //setWebChromeClient
+
+        mWebView.setDownloadListener(new DownloadListener() {
+            public void onDownloadStart(String url, String userAgent,
+                                        String contentDisposition, String mimetype,
+                                        long contentLength) {
+                try {
+                    if (url.startsWith("blob:")) {
+                        onDownloadBlob(url);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        }); // setDownloadListener
+
+        displayHtmlLoad();
+    }
+
+    class FetchWebJS {
+        FetchActivity mContext;
+
+        FetchWebJS( FetchActivity c) {
+            mContext = c;
+        }
+
+        @JavascriptInterface
+        public void onDownloadBase64( String base64, String mimetype) {
+            mContext.onDownloadBase64( base64, mimetype);
+        }
+    }
+
+    private void onDownloadBlob( String blob) {
+        String js = "javascript:("
+                + "function f() {"
+                +   "var ret = 'OK';"
+                +   "try {"
+                +       "var iaHttp = new XMLHttpRequest();"
+                +       "iaHttp.open('GET', '" + blob + "', true);"
+                +       "iaHttp.responseType = 'blob';"
+                +       "iaHttp.onload = function() {"
+                +           "if (this.status == 200) {"
+                +               "var blob = this.response;"
+                +               "var type = blob.type;"
+                +               "var rdr = new window.FileReader();"
+                +               "rdr.onloadend = function() {"
+                +                   "var b64 = btoa( rdr.result);"
+                +                   "AndroidFunction.onDownloadBase64( b64, type);"
+                +               "};"
+                +               "rdr.readAsBinaryString(blob);"
+                +           "}"
+                +       "};"
+                +       "iaHttp.send();"
+                +   "} catch( err) {"
+                +       "ret = err.message;"
+                +   "}"
+                +   "return ret;"
+                + "}"
+                + ")();";
+
+        mWebView.evaluateJavascript( js, new ValueCallback<String>() {
+            @Override
+            public void onReceiveValue(String s) {
+                logi( "onDownloadBlob " + s);
+            }
+        });
+    }
+
+    public void onDownloadBase64( String base64, String mimetype) {
+        logi( "onDownloadBase64");
+        byte[] bytes = Base64.decode(base64,Base64.DEFAULT);
+        if ( mimetype.equals( "text/plain"))
+            mimetype = "text/csv";
+        String fileName = "microbit.csv";
+        saveData( fileName, mimetype, bytes);
+    }
+
+    private void saveData( String name, String mimetype, byte[] data) {
+        Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
+        intent.addCategory(Intent.CATEGORY_OPENABLE);
+        intent.setType( mimetype);
+        intent.putExtra(Intent.EXTRA_TITLE, name);
+        dataToSave = data;
+        startActivityForResult( intent, REQUEST_CODE_SAVEDATA);
+    }
+
+    private String displayHtmlGetPath() {
+        return getCacheDir() + "/MY_DATA.HTM";
+    }
+
+    private String displayHtmlGetURL() {
+        return "file://" + displayHtmlGetPath();
+    }
+
+    private void displayHtmlDelete() {
+        File file = new File( displayHtmlGetPath());
+        if ( file.exists()) {
+            file.delete();
+        }
+    }
+
+    private boolean displayHtmlSave( ByteBuffer data) {
+        displayHtmlDelete();
+        if (data.limit() == 0) {
+            return true;
+        }
+        File file = new File( displayHtmlGetPath());
+        return FileUtils.writeBytesToFile( file, data.array());
+    }
+
+    private void displayHtmlLoad() {
+        File file = new File( displayHtmlGetPath());
+        if ( file.exists())
+        {
+            mWebView.loadUrl( displayHtmlGetURL());
+        }
+    }
+
+    private void displayHtmlGoBack() {
+        if (displayHtmlGetURL().equals(mWebView.getUrl())) {
+            activityCancelled();
+        } else if (!mWebView.canGoBack()) {
+            activityCancelled();
+        } else {
+            mWebView.goBack();
+        }
+    }
+
+}
diff --git a/app/src/main/java/com/samsung/microbit/ui/activity/PopUpActivity.java b/app/src/main/java/com/samsung/microbit/ui/activity/PopUpActivity.java
index 9dd74217..b5604927 100644
--- a/app/src/main/java/com/samsung/microbit/ui/activity/PopUpActivity.java
+++ b/app/src/main/java/com/samsung/microbit/ui/activity/PopUpActivity.java
@@ -347,6 +347,9 @@ private void setLayout(Intent intent) {
                 affirmationOKButton.setVisibility(View.VISIBLE);
                 break;
             case PopUp.TYPE_PROGRESS:
+                progressBar.setVisibility(View.VISIBLE);
+                cancelButton.setVisibility(View.VISIBLE);
+                break;
             case PopUp.TYPE_PROGRESS_NOT_CANCELABLE:
                 progressBar.setVisibility(View.VISIBLE);
                 break;
diff --git a/app/src/main/java/com/samsung/microbit/ui/activity/ProjectActivity.java b/app/src/main/java/com/samsung/microbit/ui/activity/ProjectActivity.java
index c411caef..5d3aca0f 100644
--- a/app/src/main/java/com/samsung/microbit/ui/activity/ProjectActivity.java
+++ b/app/src/main/java/com/samsung/microbit/ui/activity/ProjectActivity.java
@@ -160,6 +160,7 @@ enum Purpose {
     private static final int REQUEST_CODE_RESET_TO_BLE = 3;
     private static final int REQUEST_CODE_PAIR_BEFORE_FLASH = 4;
     private static final int REQUEST_CODE_PAIR_BEFORE_FLASH_ALREADY_RESET = 5;
+    private static final int REQUEST_CODE_FETCH = 6;
 
     private enum Screen {
         ScreenMain,
@@ -265,6 +266,11 @@ private void goToMakeCode( String hex, String name) {
         }
     }
 
+    private void goToFetch() {
+        Intent i = new Intent(this, FetchActivity.class);
+        startActivityForResult( i, REQUEST_CODE_FETCH);
+    }
+
     private void onFlashComplete() {
         switch ( mPurpose) {
             default:
@@ -538,7 +544,7 @@ private void setupFontStyle() {
         flashProjectsTitle.setTypeface(defaultTypeface);
 
         // Create projects
-        TextView createProjectText = (TextView) findViewById(R.id.custom_button_text);
+        TextView createProjectText = (TextView) findViewById(R.id.projectFetchText);
         createProjectText.setTypeface(robotoTypeface);
 
         mEmptyText.setTypeface(defaultTypeface);
@@ -1056,6 +1062,8 @@ protected void onActivityResult(int requestCode, int resultCode, Intent data) {
             case REQUEST_CODE_PAIR_BEFORE_FLASH_ALREADY_RESET:
                 onActivityResultPairing( requestCode, resultCode, data);
                 return;
+            case REQUEST_CODE_FETCH:
+                return;
         }
 
         if (requestCode == RequestCodes.REQUEST_ENABLE_BT) {
@@ -1240,8 +1248,8 @@ public void editProject(final Project project) {
     @Override
     public void onClick(final View v) {
         switch(v.getId()) {
-            case R.id.createProject:
-                scriptsPopup();
+            case R.id.projectFetch:
+                goToFetch();
                 break;
 
             case R.id.backBtn:
@@ -1255,6 +1263,10 @@ public void onClick(final View v) {
                 goToPairingFromAppBarDeviceName();
                 break;
 
+            case R.id.projectMoreButton:
+                scriptsPopup();
+                break;
+
             case R.id.viewProjectsPatternDifferent:
                 MBApp.getAppState().eventPairDifferent();
                 onPatternIsDifferent();
@@ -2471,23 +2483,20 @@ public boolean onCreateOptionsMenu(Menu menu) {
 
 
     private void scriptsPopup() {
-        PopupMenu popupMenu = new PopupMenu( this, findViewById(R.id.createProject));
+        PopupMenu popupMenu = new PopupMenu( this, findViewById(R.id.projectMoreButton));
         int itemID = Menu.FIRST;
-        popupMenu.getMenu().add( 0, itemID, 0, R.string.create_code);
+        popupMenu.getMenu().add( 0, itemID, 0, R.string.menu_import);
         itemID++;
-        popupMenu.getMenu().add( 0, itemID, 1, R.string.menu_import);
-        itemID++;
-        popupMenu.getMenu().add( 0, itemID, 2, R.string.menu_export);
+        popupMenu.getMenu().add( 0, itemID, 1, R.string.menu_export);
         itemID++;
 
         popupMenu.setOnMenuItemClickListener( new PopupMenu.OnMenuItemClickListener() {
             @Override
             public boolean onMenuItemClick(MenuItem item) {
                 switch ( item.getItemId() - Menu.FIRST) {
-                    case 0: scriptsCreateCode(); break;
-                    case 1: scriptsImport(); break;
-                    case 2: scriptsExport(); break;
-                }
+                    case 0: scriptsImport(); break;
+                    case 1: scriptsExport(); break;
+                 }
                 return false;
             }
         });
diff --git a/app/src/main/java/com/samsung/microbit/utils/BLEFetch.java b/app/src/main/java/com/samsung/microbit/utils/BLEFetch.java
new file mode 100644
index 00000000..acbf038c
--- /dev/null
+++ b/app/src/main/java/com/samsung/microbit/utils/BLEFetch.java
@@ -0,0 +1,622 @@
+package com.samsung.microbit.utils;
+
+import static android.bluetooth.BluetoothAdapter.STATE_CONNECTED;
+import static android.bluetooth.BluetoothAdapter.STATE_DISCONNECTED;
+
+import static com.samsung.microbit.BuildConfig.DEBUG;
+
+import androidx.annotation.NonNull;
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCallback;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.BluetoothStatusCodes;
+import android.content.Context;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import java.nio.ByteBuffer;
+import java.util.UUID;
+
+public class BLEFetch implements MicroBitUtility.Client {
+    private static final String TAG = BLEFetch.class.getSimpleName();
+    private Handler mainLooperHandler = null;
+
+    private BluetoothGatt mBleGatt = null;
+
+    private static final long CONNECT_TIMEOUT = 20000;
+    private static final int CONNECT_RETRIES = 1;
+    private int connectTries = 0;
+
+    public enum enumResult {
+        None,
+        Found,
+        Connected,
+        Discovered,
+        ConnectTimeout,
+        WorkTimeout,
+        Error,
+        Success,
+        Next
+    }
+    public enumResult resultState = enumResult.None;
+
+    private enum enumGattState {
+        Disconnected,
+        Connecting,
+        Connected,
+        WaitingForServices,
+        ServicesDiscovered,
+        Error,
+        Next
+    }
+    
+    private enumGattState gattState = enumGattState.Disconnected;
+    private MicroBitUtility microbitUtility = null;
+    private Boolean working = false;
+    private static final long WORK_TIMEOUT = 5000;
+
+    public MicroBitUtility.Result mWorkResult = MicroBitUtility.Result.None;
+
+    /**
+     * Callback interface for client
+     */
+    public interface Client {
+        Activity bleFetchGetActivity();
+        String bleFetchGetDeviceAddress();
+        void bleFetchProgress( float progress);
+        void bleFetchState();
+    }
+    private Client mClient;
+
+    private void logi(String message) {
+        if(DEBUG) {
+            Log.i(TAG, "### " + Thread.currentThread().getId() + " # " + message);
+        }
+    }
+
+
+    public BLEFetch( Client client) {
+        super();
+        mClient = client;
+        microbitUtility = new MicroBitUtility( this);
+        mainLooperHandler = new Handler( Looper.getMainLooper());
+    }
+
+    public void fetchCancel() {
+        logi("fetchCancel");
+        stop();
+        resultState = enumResult.None;
+    }
+
+    public Boolean fetchStart() {
+        logi("fetchStart");
+        connectTries = CONNECT_RETRIES;
+        return connectTry();
+    }
+
+    public ByteBuffer fetchData() {
+        logi("fetchData");
+        return microbitUtility.m_Data;
+    }
+
+    private Boolean connectTry() {
+        logi("connectTry");
+        stop();
+        if ( !connectStart()) {
+            return false;
+        }
+        delayStart( delayCallbackConnect, CONNECT_TIMEOUT);
+        return true;
+    }
+
+    private void stop() {
+        logi("stop");
+        delayStopAll();
+        connectStop();
+    }
+
+    private void signalResult( enumResult state) {
+        logi("signalResult " + state);
+        stop();
+        resultState = state;
+        mClient.bleFetchState();
+    }
+
+    private void signalState( enumResult state) {
+        logi("signalState " + state);
+        resultState = state;
+        mClient.bleFetchState();
+    }
+
+    private void signalProgress( float progress) {
+        logi("signalProgress " + progress);
+        mClient.bleFetchProgress( progress);
+    }
+
+    private final Runnable delayCallbackConnect = new Runnable() {
+        @Override
+        public void run() {
+            logi("delayCallbackConnect");
+            if (connectTries > 0) {
+                connectTries -= 1;
+                if (connectTry()) {
+                    return;
+                }
+            }
+            signalResult(enumResult.ConnectTimeout);
+        }
+    };
+
+    private final Runnable delayCallbackSignalState = new Runnable() {
+        @Override
+        public void run() {
+            logi("delayCallbackSignalState");
+            signalState( resultState);
+        }
+    };
+
+    private final Runnable delayCallbackWorkTimeout = new Runnable() {
+        @Override
+        public void run() {
+            logi("delayCallbackWorkTimeout");
+            signalResult(enumResult.WorkTimeout);
+        }
+    };
+
+    private final Runnable delayCallbackOnDescriptorWrite = new Runnable() {
+        @Override
+        public void run() {
+            logi("delayCallbackOnDescriptorWrite");
+            fetchOnDescriptorWrite();
+        }
+    };
+
+    private final Runnable delayCallbackDiscover = new Runnable() {
+        @SuppressLint("MissingPermission")
+        @Override
+        public void run() {
+            logi("delayCallbackDiscover");
+            if ( working && mBleGatt != null) {
+                logi("Delayed call to discoverServices()");
+                gattState = enumGattState.WaitingForServices;
+                boolean success = mBleGatt.discoverServices();
+                if (!success) {
+                    logi("ERROR_SERVICE_DISCOVERY_NOT_STARTED");
+                    gattState = enumGattState.Error;
+                    return;
+                }
+            }
+        }
+    };
+
+    private void delayStopAll()
+    {
+        logi("delayStopAll");
+        mainLooperHandler.removeCallbacks( delayCallbackConnect);
+        mainLooperHandler.removeCallbacks( delayCallbackDiscover);
+        mainLooperHandler.removeCallbacks( delayCallbackSignalState);
+        mainLooperHandler.removeCallbacks( delayCallbackWorkTimeout);
+        mainLooperHandler.removeCallbacks( delayCallbackOnDescriptorWrite);
+    }
+
+    private void delayStop( Runnable callback)
+    {
+        logi("delayStop " + callback);
+        mainLooperHandler.removeCallbacks( callback);
+    }
+
+    private void delayStart( Runnable callback, long milliseconds)
+    {
+        logi("delayStart " + callback + " ms " + milliseconds);
+        mainLooperHandler.removeCallbacks( callback);
+        mainLooperHandler.postDelayed(callback, milliseconds);
+    }
+
+    BluetoothGattCallback gattCallback = new BluetoothGattCallback() {
+        @SuppressLint("MissingPermission")
+        @Override
+        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
+            super.onConnectionStateChange(gatt, status, newState);
+
+            if ( !working) {
+                return;
+            }
+
+            logi("onConnectionStateChange " + newState + " status " + status);
+            if ( status != BluetoothGatt.GATT_SUCCESS) {
+                connectStop();
+                logi("ERROR - status");
+                logi("Prepare for retry after a short delay");
+                gattState = enumGattState.Error;
+                resultState = enumResult.Found;
+                delayStart( delayCallbackConnect, 1000);
+                return;
+            }
+
+            if ( newState == STATE_CONNECTED) {
+                logi("STATE_CONNECTED");
+                gattState = enumGattState.Connected;
+                resultState = enumResult.Connected;
+                delayStop( delayCallbackConnect);
+                delayStart( delayCallbackSignalState, 1);
+                /*
+                 * Nordic says to wait 1600ms for possible service changed before discovering
+                 * https://github.com/NordicSemiconductor/Android-DFU-Library/blob/e0ab213a369982ae9cf452b55783ba0bdc5a7916/dfu/src/main/java/no/nordicsemi/android/dfu/DfuBaseService.java#L888
+                 */
+                if ( gatt.getDevice().getBondState() == BluetoothDevice.BOND_BONDED) {
+                    logi("Already bonded - delay calling discoverServices()");
+                    delayStart( delayCallbackDiscover, 1600);
+                    // NOTE: This also works with shorted waiting time. The gatt.discoverServices() must be called after the indication is received which is
+                    // about 600ms after establishing connection. Values 600 - 1600ms should be OK.
+                } else {
+                    logi("calling discoverServices()");
+                    gattState = enumGattState.WaitingForServices;
+                    boolean success = gatt.discoverServices();
+                    if (!success) {
+                        logi("ERROR - discoverServices() failed");
+                        logi("Prepare delayed retry");
+                        gattState = enumGattState.Error;
+                        delayStart( delayCallbackConnect, 1000);
+                        return;
+                    }
+                }
+            }
+            else if( newState == STATE_DISCONNECTED) {
+                logi("STATE_DISCONNECTED");
+            }
+        }
+
+        @SuppressLint("MissingPermission")
+        @Override
+        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
+            super.onServicesDiscovered(gatt, status);
+            if ( !working) {
+                return;
+            }
+            logi("onServicesDiscovered status " + status);
+            if ( status != BluetoothGatt.GATT_SUCCESS) {
+                connectStop();
+                logi("ERROR - status");
+                logi("Prepare for retry after a short delay");
+                gattState = enumGattState.Error;
+                resultState = enumResult.Found;
+                delayStart( delayCallbackConnect, 1000);
+                return;
+            }
+
+            gattState = enumGattState.ServicesDiscovered;
+            resultState = enumResult.Discovered;
+            delayStop( delayCallbackConnect);
+            delayStart( delayCallbackSignalState, 1);
+            fetchOnDiscovered();
+        }
+
+        @Override
+        public void onCharacteristicWrite( BluetoothGatt gatt,
+                                           BluetoothGattCharacteristic characteristic,
+                                           int status) {
+            logi( "onCharacteristicWrite " + status);
+            if ( status != BluetoothGatt.GATT_SUCCESS) {
+                connectStop();
+                gattState = enumGattState.Error;
+                delayStart( delayCallbackConnect, 1000);
+                return;
+            }
+        }
+
+        @Override
+        public void onCharacteristicRead(@NonNull BluetoothGatt gatt,
+                                         @NonNull BluetoothGattCharacteristic characteristic,
+                                         @NonNull byte[] value,
+                                         int status) {
+            logi( "onCharacteristicRead " + status);
+            if ( status != BluetoothGatt.GATT_SUCCESS) {
+                connectStop();
+                gattState = enumGattState.Error;
+                delayStart( delayCallbackConnect, 1000);
+                return;
+            }
+            
+            BluetoothGattCharacteristic musc = findCharacteristic(MICROBIT_UTILITY_SERVICE, MICROBIT_UTILITY_CTRL);
+            
+            if ( characteristic.getUuid().equals( musc.getUuid())) {
+                fetchOnCharacteristicChanged( value, value.length);
+            }
+        }
+
+        @Override
+        public void onCharacteristicChanged(@NonNull BluetoothGatt gatt,
+                                            @NonNull BluetoothGattCharacteristic characteristic,
+                                            @NonNull byte[] value) {
+            logi( "onCharacteristicChanged");
+            BluetoothGattCharacteristic musc = findCharacteristic(MICROBIT_UTILITY_SERVICE, MICROBIT_UTILITY_CTRL);
+
+            if ( characteristic.getUuid().equals( musc.getUuid())) {
+                fetchOnCharacteristicChanged( value, value.length);
+            }
+        }
+
+        @Override
+        public void onDescriptorRead(@NonNull BluetoothGatt gatt,
+                                     @NonNull BluetoothGattDescriptor descriptor,
+                                     int status,
+                                     @NonNull byte[] value) {
+            logi( "onDescriptorRead " + status);
+        }
+
+        @Override
+        public void onDescriptorWrite(BluetoothGatt gatt,
+                                      BluetoothGattDescriptor descriptor,
+                                      int status) {
+            logi( "onDescriptorWrite " + status);
+            if ( status != BluetoothGatt.GATT_SUCCESS) {
+                connectStop();
+                gattState = enumGattState.Error;
+                delayStart( delayCallbackConnect, 1000);
+                return;
+            }
+            delayStart( delayCallbackOnDescriptorWrite, 100);
+        }
+    };
+
+    @SuppressLint("MissingPermission")
+    private void connectStop() {
+        logi("connectStop");
+        working = false;
+        if ( mBleGatt != null) {
+            fetchOnDisconnect();
+            mBleGatt.disconnect();
+            mBleGatt.close();
+            mBleGatt = null;
+            gattState = enumGattState.Disconnected;
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    private boolean connectStart() {
+        logi("connectStart");
+        if ( working) {
+            return true;
+        }
+        connectStop();
+
+        Context context = mClient.bleFetchGetActivity();
+        String address = mClient.bleFetchGetDeviceAddress();
+        if ( context == null || address == null) {
+            return false;
+        }
+        BluetoothManager manager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
+        if ( manager == null) {
+            return false;
+        }
+        BluetoothAdapter adapter = manager.getAdapter();
+        if ( adapter == null) {
+            return false;
+        }
+        if (!adapter.isEnabled()) {
+            return false;
+        }
+        BluetoothDevice device = adapter.getRemoteDevice( address);
+        if ( device == null) {
+            return false;
+        }
+
+        gattState = enumGattState.Connecting;
+        working = true;
+        mBleGatt = connect( device, gattCallback);
+        if ( mBleGatt == null) {
+            working = false;
+            return false;
+        }
+        return true;
+    }
+
+    @SuppressLint("MissingPermission")
+    private  BluetoothGatt connect( BluetoothDevice device, BluetoothGattCallback bluetoothGattCallback)
+    {
+        BluetoothGatt gatt;
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            gatt = device.connectGatt(
+                    mClient.bleFetchGetActivity(),
+                    false,
+                    bluetoothGattCallback,
+                    BluetoothDevice.TRANSPORT_LE,
+                    BluetoothDevice.PHY_LE_1M_MASK | BluetoothDevice.PHY_LE_2M_MASK);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            gatt = device.connectGatt(
+                    mClient.bleFetchGetActivity(),
+                    false,
+                    bluetoothGattCallback,
+                    BluetoothDevice.TRANSPORT_LE);
+        } else {
+            gatt = device.connectGatt(
+                    mClient.bleFetchGetActivity(),
+                    false,
+                    bluetoothGattCallback);
+        }
+
+        return gatt;
+    }
+    
+    private BluetoothGattCharacteristic findCharacteristic(UUID uuidService, UUID uuidChr) {
+        BluetoothGattService s = mBleGatt.getService( uuidService);
+        return s == null ? null : s.getCharacteristic( uuidChr);
+    }
+
+    @SuppressLint("MissingPermission")
+    private int writeCharacteristic( BluetoothGattCharacteristic c, byte[] data, int writeType) {
+        logi( "writeCharacteristic " + c.getUuid() + " writeType " + writeType);
+        //onWriteCharacteristicStatus = BLE_PENDING;
+        if ( Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            c.setWriteType( writeType);
+            c.setValue(data);
+            int status = mBleGatt.writeCharacteristic(c) ? BluetoothGatt.GATT_SUCCESS : BLE_ERROR_UNKNOWN;
+            logi( "writeCharacteristic (legacy) status " + status);
+            return status;
+        }
+
+        int status = mBleGatt.writeCharacteristic( c, data, writeType);
+        logi( "writeCharacteristic status " + status);
+        return status;
+    }
+
+    @SuppressLint("MissingPermission")
+    private boolean cccEnableNotify( BluetoothGattCharacteristic chr, boolean enable) {
+        logi( "cccEnableNotify " + enable);
+        BluetoothGattDescriptor ccc = chr.getDescriptor(CLIENT_CHARACTERISTIC_CONFIG);
+        if (ccc == null) {
+            return false;
+        }
+
+        byte [] value = enable
+                ? BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+                : BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE;
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            int status = mBleGatt.writeDescriptor( ccc, value);
+            if ( status != BluetoothStatusCodes.SUCCESS) {
+                return false;
+            }
+        } else {
+            ccc.setValue(value);
+            if ( !mBleGatt.writeDescriptor(ccc)) {
+                return false;
+            }
+        }
+
+        return mBleGatt.setCharacteristicNotification( chr, enable);
+    }
+    
+    public static final UUID MICROBIT_UTILITY_SERVICE   = UUID.fromString("E95D0001-251D-470A-A062-FA1922DFA9A8");
+    public static final UUID MICROBIT_UTILITY_CTRL      = UUID.fromString("E95D0002-251D-470A-A062-FA1922DFA9A8");
+    public static final int MICROBIT_PDU_SIZE  = 20;
+    private final static int BLE_ERROR_UNKNOWN = Integer.MAX_VALUE;
+    private static final UUID CLIENT_CHARACTERISTIC_CONFIG = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
+
+    @Override
+    public MicroBitUtility.Result microbitUtilityWriteCharacteristic(byte[] data, int dataLength) {
+        BluetoothGattCharacteristic c = findCharacteristic(MICROBIT_UTILITY_SERVICE, MICROBIT_UTILITY_CTRL);
+        if ( c == null) {
+            return MicroBitUtility.Result.NoService;
+        }
+        int status = writeCharacteristic( c, data, BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE);
+        if( status != BluetoothGatt.GATT_SUCCESS) {
+            return MicroBitUtility.Result.BleError;
+        }
+        return MicroBitUtility.Result.None;
+    }
+
+    private void fetchSignalError( MicroBitUtility.Result result) {
+        logi("fetchSignalError " + result);
+        mWorkResult = result;
+        signalResult( enumResult.Error);
+    }
+
+    private void fetchSignalFinished( MicroBitUtility.Result result) {
+        logi("fetchSignalFinished " + result);
+        mWorkResult = result;
+        signalResult( enumResult.Success);
+    }
+    
+    private void fetchSignalProgress( float progress) {
+        logi("fetchSignalProgress " + progress);
+        signalProgress( progress);
+    }
+
+    private void fetchTimeoutStop() {
+        delayStop( delayCallbackWorkTimeout);
+    }
+
+    private void fetchTimeoutStart() {
+        delayStart( delayCallbackWorkTimeout, WORK_TIMEOUT);
+    }
+
+    private void fetchOnDisconnect()
+    {
+        fetchTimeoutStop();
+        logi( "fetchOnDisconnect");
+
+        BluetoothGattCharacteristic c = findCharacteristic(MICROBIT_UTILITY_SERVICE, MICROBIT_UTILITY_CTRL);
+        if ( c != null) {
+            cccEnableNotify( c,false);
+        }
+    }
+
+    private void fetchOnDiscovered()
+    {
+        fetchTimeoutStop();
+        logi( "fetchOnDiscovered");
+
+        BluetoothGattService s = mBleGatt.getService(UUID.fromString("0000fe59-0000-1000-8000-00805f9b34fb"));
+        BluetoothGattCharacteristic c = findCharacteristic(MICROBIT_UTILITY_SERVICE, MICROBIT_UTILITY_CTRL);
+
+        if ( s == null) {
+            fetchSignalError( MicroBitUtility.Result.V2Only);
+        } else if ( c == null) {
+            fetchSignalError( MicroBitUtility.Result.NoService);
+        } else if ( !cccEnableNotify( c, true)) {
+            fetchSignalError( MicroBitUtility.Result.BleError);
+        } else {
+            fetchTimeoutStart();
+        }
+    }
+
+    private void fetchOnDescriptorWrite() {
+        fetchTimeoutStop();
+        logi( "fetchOnDescriptorWrite");
+        MicroBitUtility.Result result = microbitUtility.startLogDownload();
+        if ( result != MicroBitUtility.Result.None) {
+            fetchSignalError( result);
+            return;
+        }
+        fetchTimeoutStart();
+    }
+
+    private void fetchOnCharacteristicChanged( byte[] value, int length)
+    {
+        if ( !working)
+            return;
+
+        fetchTimeoutStop();
+        logi( "fetchOnCharacteristicChanged");
+
+        if ( value.length > MICROBIT_PDU_SIZE) {
+            fetchSignalError( MicroBitUtility.Result.Protocol);
+            return;
+        }
+
+        MicroBitUtility.Result result = microbitUtility.process( value, length);
+
+        switch ( result)
+        {
+            case None:
+                fetchSignalProgress( microbitUtility.progress());
+                fetchTimeoutStart();
+                break;
+
+            case Finished:
+                fetchSignalFinished( result);
+                break;
+
+            case NoData:
+            case BleError:
+            case V2Only:
+            case NoService:
+            case Protocol:
+            case OutOfMemory:
+            default:
+                fetchSignalError( result);
+                break;
+        }
+    }
+}
diff --git a/app/src/main/java/com/samsung/microbit/utils/MicroBitUtility.java b/app/src/main/java/com/samsung/microbit/utils/MicroBitUtility.java
new file mode 100644
index 00000000..20cfbe5a
--- /dev/null
+++ b/app/src/main/java/com/samsung/microbit/utils/MicroBitUtility.java
@@ -0,0 +1,229 @@
+package com.samsung.microbit.utils;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+class MicroBitUtility
+{
+  public enum Result
+  {
+    None,
+    BleError,
+    V2Only,
+    NoService,
+    Protocol,
+    NoData,
+    OutOfMemory,
+    Finished
+  }
+
+  private static final int requestTypeNone = 0;
+  private static final int requestTypeLogLength = 1;  // reply data = 4 bytes log data length
+  private static final int requestTypeLogRead = 2;    // reply data = up to 19 bytes of log data
+
+  private static final int requestLogHTMLHeader = 0;
+  private static final int requestLogHTML = 1;
+  private static final int requestLogCSV = 2;
+
+  private static final int jobLowMAX = 0x0E;
+  private static final int jobLowERR = 0x0F;     // reply data = 4 bytes signed integer error
+
+  int  m_Job;
+  int  m_JobLow;
+
+  int m_Request;
+  int m_Length;
+  int m_Batch;
+  int m_Index;
+  int m_BatchLength;
+  int m_BatchReceived;
+  int m_Received;
+
+  ByteBuffer m_Data;
+
+  /**
+   * Callback interface for client
+   */
+  public interface Client {
+      MicroBitUtility.Result microbitUtilityWriteCharacteristic( final byte [] data, int dataLength);
+  }
+  private MicroBitUtility.Client mClient;
+
+  public MicroBitUtility( MicroBitUtility.Client client) {
+    super();
+    mClient = client;
+    m_Job = 0;
+    m_JobLow = 0;
+    m_Request = requestTypeNone;
+    m_Index = 0;
+    m_Length = 0;
+    m_Received = 0;
+    m_Batch = 4;          // If > 4, nearly every batch has to wait for a free slot
+    m_BatchLength = 0;
+    m_BatchReceived = 0;
+    m_Data = null;
+  }
+
+  public ByteBuffer resultData()   { return m_Data; }
+  public long       resultLength() { return m_Length; }
+
+  public MicroBitUtility.Result startLogDownload() {
+    m_Index = 0;
+    m_Length = 0;
+    m_Received = 0;
+
+    m_Request = requestTypeLogLength;
+    m_Job += 0x10;
+    if ( m_Job == 0x100)
+      m_Job = 0;
+    m_JobLow = 0;
+    //    typedef struct requestLog_t
+    //    {
+    //        uint8_t  job;
+    //        uint8_t  type;                  // requestType_t
+    //        uint8_t  format;                // requestLogFormat
+    //    } requestLog_t;
+    int requestSize = 3;
+    byte [] request = new byte[ requestSize];
+    Arrays.fill( request, (byte) 0);
+    request[ 0] = (byte) m_Job;
+    request[ 1] = (byte) m_Request;
+    request[ 2] = (byte) requestLogHTML;
+    return mClient.microbitUtilityWriteCharacteristic( request, requestSize);
+  }
+
+  public MicroBitUtility.Result process( final byte [] reply, int replyLength) {
+    //    typedef struct reply_t
+    //    {
+    //        uint8_t  job;                   // Service cycles low nibble i.e client job + { 0x00, 0x01, 0x02, ..., 0x0E, 0x00, ... }
+    //                                        // low nibble == 0x0F (jobLowERR) indicates error and data = 4 bytes signed integer error
+    //        uint8_t  data[19];
+    //    } reply_t;
+
+    if ( replyLength == 0)
+      return MicroBitUtility.Result.Protocol;
+
+    int replyJob = reply[0];
+
+    if ( ( replyJob & 0xF0) != m_Job)
+      return MicroBitUtility.Result.None; // Ignore if not the current job
+
+    if ( ( replyJob & 0x0F) == jobLowERR)
+      return MicroBitUtility.Result.Protocol; // Reply is error
+
+    if ( ( replyJob & 0x0F) != m_JobLow)
+      return MicroBitUtility.Result.Protocol; // Reply is out of order
+
+    m_JobLow++;
+    if ( m_JobLow == 0x0F)
+      m_JobLow = 0;
+
+    int dataLength = replyLength - 1;
+    byte [] data = new byte[ dataLength];
+    System.arraycopy( reply, 1, data, 0, dataLength);
+
+    MicroBitUtility.Result result = MicroBitUtility.Result.None;
+
+    switch ( m_Request)
+    {
+      case requestTypeLogLength:
+        result = logLengthProcess( data, dataLength);
+        break;
+      case requestTypeLogRead:
+        result = logReadProcess( data, dataLength);
+        break;
+    }
+    return result;
+  }
+
+  public float progress() {
+    float progress = (float) m_Index / m_Length;
+    if ( progress < 0) progress = 0;
+    if ( progress > 1) progress = 1;
+    return progress;
+  }
+
+  public MicroBitUtility.Result logRead() {
+    m_BatchReceived = 0;
+    m_BatchLength = m_Length - m_Received;
+    if ( m_BatchLength > 19 * m_Batch)
+      m_BatchLength = 19 * m_Batch;
+
+    m_Request = requestTypeLogRead;
+    m_Job += 0x10;
+    if ( m_Job == 0x100)
+      m_Job = 0;
+    m_JobLow = 0;
+    //    typedef struct requestLogRead_t
+    //    {
+    //        uint8_t  job;
+    //        uint8_t  type;                  // requestType_t
+    //        uint8_t  format;                // requestLogFormat
+    //        uint8_t  reserved;              // set to zero
+    //        uint32_t index;                 // index into data
+    //        uint32_t batchlen;              // size in bytes to return
+    //        uint32_t length;                // length of whole file, from requestTypeLogLength
+    //    } requestLogRead_t;
+    int requestSize = 16;
+    byte [] request = new byte[ requestSize];
+    Arrays.fill( request, (byte) 0);
+    request[ 0] = (byte) m_Job;
+    request[ 1] = (byte) m_Request;
+    request[ 2] = (byte) requestLogHTML;
+    request[ 3] = (byte) 0;
+    byte [] index = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt( m_Index).array();
+    System.arraycopy( index, 0, request, 4, 4);
+    byte [] batchlen = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt( m_BatchLength).array();
+    System.arraycopy( batchlen, 0, request, 8, 4);
+    byte [] length = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt( m_Length).array();
+    System.arraycopy( length, 0, request, 12, 4);
+    return mClient.microbitUtilityWriteCharacteristic( request, requestSize);
+  }
+
+  public MicroBitUtility.Result logLengthProcess( final byte [] data, int dataLength) {
+    if ( dataLength < 4)
+      return MicroBitUtility.Result.Protocol;
+
+    try {
+      ByteBuffer bb = ByteBuffer.allocate(4);
+      bb.put(data, 0, 4);
+      bb.rewind();
+      m_Length = bb.order(ByteOrder.LITTLE_ENDIAN).getInt();
+      if (m_Length == 0)
+        return MicroBitUtility.Result.NoData;
+
+      m_Data = ByteBuffer.allocate(m_Length);
+    } catch ( Exception e) {
+      return MicroBitUtility.Result.OutOfMemory;
+    }
+
+    m_Index = 0;
+    m_Received = 0;
+    return logRead();
+  }
+
+  public MicroBitUtility.Result logReadProcess( final byte [] data, int dataLength) {
+    if ( dataLength < 1)
+      return MicroBitUtility.Result.Protocol;
+
+    if ( m_Data.remaining() < m_Length - m_Received)
+      return MicroBitUtility.Result.Protocol;
+
+    m_Data.put( data, 0, dataLength);
+    m_Received += dataLength;
+    m_BatchReceived += dataLength;
+
+    if ( m_BatchReceived == m_BatchLength)
+    {
+      m_Index += m_BatchReceived;
+
+      if ( m_Received == m_Length)
+        return MicroBitUtility.Result.Finished;
+
+      return logRead();
+    }
+
+    return MicroBitUtility.Result.None;
+  }
+}
diff --git a/app/src/main/res/drawable-hdpi/ic_discover_black.png b/app/src/main/res/drawable-hdpi/ic_discover_black.png
new file mode 100644
index 0000000000000000000000000000000000000000..8e33b28ae39bea2c22391d19283ce1dd19716fc7
GIT binary patch
literal 5215
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-hdpi/ic_fetch.png b/app/src/main/res/drawable-hdpi/ic_fetch.png
new file mode 100644
index 0000000000000000000000000000000000000000..c766f07ebac77ba872ee140b2eee2ac38a8a6237
GIT binary patch
literal 6652
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-hdpi/ic_more_vdotw.png b/app/src/main/res/drawable-hdpi/ic_more_vdotw.png
new file mode 100644
index 0000000000000000000000000000000000000000..dde168c0fd9777f4960cb10f247701dd5e08a444
GIT binary patch
literal 334
zcmeAS@N?(olHy`uVBq!ia0vp^5+KaM1|%Pp+x`GjoCO|{#Xvd&gc&Ptc_#rGk|nMY
zCBgY=CFO}lsSM@i<$9TU*~Q6;1*v-ZMd`EO*+>Bu-S%{G4Dsl^JJp)&kb{V;dKuS7
zvocTBJcpc^rq10$<_hnWqcWtV3z-)cD&LZw&A6EFiEl+yMPk>^g8MW7OFULoU=*6)
zv!y^>qhb|<lkb5h|Ffz$r%f;{sz~-daP#5ZmYY?Kf&pREo-=(>xp{#3lG!nzoN{@V
zgL_XV{Es-m6LEW5?cyK1gM1GhV?3c6`O?<mg{kla%QS;f<_Hh2C)-|%{m=YqBP#p(
zSIC_!Zj4_Vvs0VB6)v%?ky)OhdD83s!2=I@O&Q(W%LUS2v$h;qx5*~j#Qrar23ykn
aGt4#@8RxNT<*)<2$>8bg=d#Wzp$P!Ob$zM;

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-ldpi/ic_discover_black.png b/app/src/main/res/drawable-ldpi/ic_discover_black.png
new file mode 100644
index 0000000000000000000000000000000000000000..2a393cb9c2ef0cc723c43c31604948f2ba4b6474
GIT binary patch
literal 5045
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
U+{oH*gX|TG>l@%x<F#_#KREZ0kpKVy

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-ldpi/ic_fetch.png b/app/src/main/res/drawable-ldpi/ic_fetch.png
new file mode 100644
index 0000000000000000000000000000000000000000..4caec726a6e1fdc645fe6cd63d7cbd2899eb9943
GIT binary patch
literal 4993
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
QXvP>$P<Y_cfK@sF1;~(iVE_OC

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-ldpi/ic_more_vdotw.png b/app/src/main/res/drawable-ldpi/ic_more_vdotw.png
new file mode 100644
index 0000000000000000000000000000000000000000..a90d27278db5619ff4f63069fe42cf1f1cec30db
GIT binary patch
literal 269
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`oCO|{#X#B`gc)~a@qGd^BuiW)
zN`mv#O3D+9QW?t2%k?tzvWt@w3sUv+i_&MmvylQSn&s)@7-G@8c9J0%lOvC7eT!{p
z^samE?-lO3>1?^0ydyee?eoAIF}68}c+RbnXOjF;Su@Fyl}XCeyI$_h8@Wp51JnA=
zTo3c@P;JP5GCM`0+Oy(qmvBXw*o-jVelY`fwgv3Fqz+8b+1OvRQ&s4Tz4{BAf1EQ!
zng1!-Cr4ZFVVf7XTI#@y^);Tqic>cEG`U@JdM_+@_RYt$-<j0rwdG#sJ>&^=C4;A{
KpUXO@geCwHykK_#

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-mdpi/ic_discover_black.png b/app/src/main/res/drawable-mdpi/ic_discover_black.png
new file mode 100644
index 0000000000000000000000000000000000000000..cd94526efbd8ee350c2adb7e9abb278de6a604df
GIT binary patch
literal 5045
zcmeHKc~lek77mL9gNhVHi&%$%h-mgbBp?J7lt5Sw6tI)Y1P94t5+I-~Dk1`6alxWh
zo+57aq0%SV3PlmMY*s5p1x3UPXvGaGxD?+cpyGM`$8%o)Gv`b)bC>Vl``tVD<hMx_
zuy``g4u`>DCj0q%2cy5U^_RJs{=3|kgTWX-O$iligTW*~rB=$2co@(ot6%`uAu<d`
z*WO<ko&US*qz$(t&M$DNq%fNtUi&6tlU@vAj`%N2sG^q??VKMb%9z2<@DPOcy&0j^
zS@O0MvJUsmJEZN}#E}sX51%NmP;<K*hc2FK@4NBEBeN_&QRB#<_RsX|_ieBHcnUqt
zlWXiQ^=8?VQq!%vqkoRN@?F(Zm*rk{r`HnKR#YV%c=&vkMeOZ+jI`56%5NeDd*Sq#
zOx>}0JytzLC#<^g)O28AvnS3KxyN+N`B!;&)3fWY_Rn?{=UbNHj)gw5ONG+c;*k!M
zNxxk3PkK?hXYhR5#H@SWmb9fcv1t{%Z-($V$v;7KOK7m>^k>#lyUK<9%8Ix?UERHk
ztT|5S$_{rd`Mkkof0c2v+k;j3u*Ui`RF~iquk|lo=Z7tzsAB=Jr?Db_ig!_&y%G7Y
zKmEGXQWH`kuG)D1?Unl&%9yKRYX6(&{32k{jI*FD-7$4O{lcW={pXa+!Dyc4ghEO~
zi+xSE`_FFqTF!7mOmRclLeb9Mvt};1_`{rl()pD#`vzk|-(i=b2*;H>F;SU6Ov`mJ
zTI*QgGKZUYBfD!cw%FL=qURlJbKe~^!yAH}jPeJ*oeAZIFAwjO-HgEOV~fq`5jb&6
z?&PP?6)S;{PsvedMnX&E)&t+rOQlFm+WGqZN9NEpP2o|zA5+vC%e^(yOY53~G>wJ)
z-YA?iK}4JpeR<#ZZGoJ-M`F4CgS6sO{F=D$B129-*w+(j$3jlcjf`unz8B6-$PC^R
zz4}30O>c~um;C2!!D2h+n%{#IaW>4h!28#ZTv=~N3jV(2Rx7#np@ZiD_e#U0diH18
z9Zne;Jq-_4IR)puSw*vwJCR0lX#jh(Gi7St9x?XT!?dldyKN<}9Tl&E>CQjadJ_G$
zx4(YX+;0&lA8BtD)Zyt{?r0x4u+#c3*BsyZqU3oKJbcSYxv%Q-mwkjm+Z2nM4I>_2
zCh1>LM-IHf-mxknt(Ly{3xhGrL<9nnpFr?-_|cL7HnqUb_uNAJ3$+Ieb3*N#0e3)<
zP$3Gf4=NL7;`W8F`0Xt3<vQodemS`%U6HCMC&US=Rc*hW4V!8@8@MzjAcq*-{bs9I
z?hMQPS5I%H&Q7{*6jic+MffuN%i0eAxz=9HD%Z^AR&`T#c>r-<A!TmPyy5&~t4*(`
zOot*ydPnSQ;yQyfG8Xd6W*ih&d-7_KnR!E-l1rVA)c4lkb&mdexZr-pMP*(tQL|th
zi*`R*vRCYqc>LzsB@M0Fhq6nK9t?5c`KK7JJ})k7-QLE(Vd0pZ3K!j{Z!D<C7Xn@x
zd3KG5&n(Id-(zEev<D6kW20+*iA7Pc%kSca)9jqCSw6?so<51&W*rmkWRw|W-wWB8
zKQ?ap@$Q=0ZUF<P=I$oTQaYB)F|^_X*E%8x&HFmch~*u-s<BazFeZUn(k10K2O6f~
z&b<0OHDpR(?Sz!J>dwel>{JZ3HSB>In{9d_XM4?~fk%%nb&l|_K6s3+%v0A5nuto#
zC1sDG%SbHr=R!(35tJ$=Fi|I0q00(`;d$s(AhZ(J0uneDQSkAPPuJoBM9Rl6V+hGY
zl>lCW_@=1gkd%N>C}kzYk>WkvaXcLt1(3s95YWlv6&kLNk2m0Q(R;m^ga-^J+Le5~
zSSSJnN;M47iF6{F;G;tlsd#rBz*9?Q++goTV-V;QAHPDYRdGqAq@*Nb5{;--$C4-<
z4u?dhlBiSyYC+H>E3}}FpwKw#Ax1I0VGX24R9Zx-0Q8ukM46!F<MF5-c$=SGB^17c
zS7^pqK=~l)KoyBXB$MQF(s&Pz)+Z4K8B6GIJv5={PA3J!8fAhSf_)NUh1PLAgcN$`
zuS!tI8_JPFBsd<Hqox`(D&>Qai~WS6cOH5QViCE@;DwU?fu$Cay(jB~-1HhlIpY&S
z-QVGUVEwjsgE49)6mq?lP=Y=^KW{!>AD=5#LWq=WxFxe-iiAO@6Q~>-l|ZMGsRRy8
zW)R418YGc&Br=Fe83*O3&}cyg1nZ$ta3X@@K#)|zrcz-7n<|qK=#Yd>V6$Wt0!K=t
zGHGNcRRT-KK?JH1bSlC4@mcAiq$m_fr%GX(3?@jVEGB`@VMz%RhKxagIZTj6rZPAZ
z4rqXqLfl14wH!p-iO9iNn50s~8WeiMxt=0FKAuV>zn6&OL9GmR;NyiL1O$e>*MuT+
zI7AET>7=kIEH;@!W;19EDjM#+Q8=vDprfb<rI3kKx<RAw3m2^hWfs&ADhgnbqs4Fq
zY8cci)uBpdJRh&m3DA2Q<{RLRcEuObpccvcksllS5O~$-)95=8j~G+{V3=Dj2#p5O
zfQhiw5D4`fRY5C2MJ$ZI;A0c@R*w8lw`d$HlP&=n1SW*`h|UJt1PPlVA<)pW(FYd9
zVR1f0*C=J$Bv1`|#-f#?)u0n(s0MHu<#OJK=1D7HJyB#Toj_(1$gEH*jmuzj$&C4A
z3YSdAlg270>EG+OCG$xCLkiDeFm4f`exovU!Jzw!^lo8|k*4SIAN-6p;~$KGLVpVK
zQT%?Q>l0lc#lS}yf10jObbS;9A7%V$y8dr;;ocv4U<LX&C<#5#h}{z!(Zi6LWa(mW
z%u~!k%t6JndwWpHM3rxZ27|G%)?Y@LUEj_?g;=eh&<ERRhPCBRKzJ4s^u)W_&)YN9
z_hNrr?UGqRQ_Y?f4+V;j`&qR{1yP1En@lM?4&uZUByzal;swsO+a$Zx*(uV`+r-F<
zlJylhwb^HP$%2hFH$0MjCSYw7dz*{4473y}3+JvjP0TDK7Jpeb&D7(&XHF;GBz=?8
zzh9SvbDp(0-G8}su5QD$N#Pk0*DIg3R$IwmX6CM2Xu>}4`ttb3J1#wzdt>Lgu3qnv
z`PUx>Z)_f)C{BE)IGYYRJ&ew6yF@PBTIJaP#Nz7OkvGx#+_bErW4b-!jtfzjH`um2
zxNm!2V*F?MA@g4nZLZeAG3{Hf>^9M{Ck$t8n%KN?Xy=|YO*zfxOv?5r(O=mL*Ibl_
zZ(TI8%VEvg-0TyqVJoLoShujIKm2`nnf_F7lem8W$#rice(Rd;*v0I;qp2HuTyEC%
zS)ui9rC{RL!9zPLgTh*-ueXiw`Z9lbfGmxR5S03sCH(qgcV*<MW65d9Jgm1^zdl;;
z9~e_!9vDNK*x79NMZ~|E+3Nwor}5V*T`kpf`dfQTrfvVvwQYRw(`GZ5<V3V@JZ_8j
P3ghP!;9c(Z)w=%zd~%3j

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-mdpi/ic_fetch.png b/app/src/main/res/drawable-mdpi/ic_fetch.png
new file mode 100644
index 0000000000000000000000000000000000000000..4ae00e08caa06e07d4ed95637b3aab770a115dc4
GIT binary patch
literal 4992
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
Qjb)7E1xExO4@}DaFQ|`mhX4Qo

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-mdpi/ic_more_vdotw.png b/app/src/main/res/drawable-mdpi/ic_more_vdotw.png
new file mode 100644
index 0000000000000000000000000000000000000000..a90d27278db5619ff4f63069fe42cf1f1cec30db
GIT binary patch
literal 269
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`oCO|{#X#B`gc)~a@qGd^BuiW)
zN`mv#O3D+9QW?t2%k?tzvWt@w3sUv+i_&MmvylQSn&s)@7-G@8c9J0%lOvC7eT!{p
z^samE?-lO3>1?^0ydyee?eoAIF}68}c+RbnXOjF;Su@Fyl}XCeyI$_h8@Wp51JnA=
zTo3c@P;JP5GCM`0+Oy(qmvBXw*o-jVelY`fwgv3Fqz+8b+1OvRQ&s4Tz4{BAf1EQ!
zng1!-Cr4ZFVVf7XTI#@y^);Tqic>cEG`U@JdM_+@_RYt$-<j0rwdG#sJ>&^=C4;A{
KpUXO@geCwHykK_#

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-mdpi/v2only.png b/app/src/main/res/drawable-mdpi/v2only.png
new file mode 100644
index 0000000000000000000000000000000000000000..3c22ddf3e68ca28adf94c6d50ad69d2a5df2a4ba
GIT binary patch
literal 17713
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
Wzf9iy+y&lDgDA<V%hpI+MEoC|f&8Wb

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xhdpi/ic_discover_black.png b/app/src/main/res/drawable-xhdpi/ic_discover_black.png
new file mode 100644
index 0000000000000000000000000000000000000000..94a5972b234c44dfeacb96f3f6961a85e4e43106
GIT binary patch
literal 5342
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
Ci6}$>

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xhdpi/ic_fetch.png b/app/src/main/res/drawable-xhdpi/ic_fetch.png
new file mode 100644
index 0000000000000000000000000000000000000000..87a07f26642c409002b01ff54161e941e1aa2ecf
GIT binary patch
literal 5158
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xhdpi/ic_more_vdotw.png b/app/src/main/res/drawable-xhdpi/ic_more_vdotw.png
new file mode 100644
index 0000000000000000000000000000000000000000..310038895fe5041696ec6d0bc1d8b3102d0744c5
GIT binary patch
literal 424
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz&H|6fVjx`x!i;{^Y8*g@WQl7;
zNpOBzNqJ&XDnogBxn5>oc5!lIL8@MUQTpt6Hc|`>jHaG0jv*1PZ>OL2baoVJJ%83r
zZ^{y`!u8R<VNP!jX7K*YIpW6i(qU4AZU!^gB2^7BffLUk^=f>yv@oA6sK}o7(W2n|
z@jce{m+D0>u(ch?mSA2Gt5w5W@oe|JhBVHG)3ZMC$1b^+Z6UEu`JNwVgZc95?hfoT
zuKN7vxe;sS&|ty3EdJ2)1D(sK=`w88%(Sn$H{)jW_G@1CTH*Xa@78+SdV0+AkeVSW
zd9#j>UCs1#0n3irR;&*!Hi>=@eqC91DDH^02BSc55q|~4F+cr&25w&S_1XTyRnr%G
zT3t!E?@{IL);T=2D0|}L3h%3hJ*yu7u#>*3f9QO+o=W=CL%Szx-;B$$J?~bs<X3$9
z!Dy=kRYz`XFcye^%#;0kiN$2)yu{B{OO9ODaoDm#Zi#+k4C7j*hdaOWxr$^cN<8c7
Q1%@(%r>mdKI;Vst0ASdp00000

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xxhdpi/ic_discover_black.png b/app/src/main/res/drawable-xxhdpi/ic_discover_black.png
new file mode 100644
index 0000000000000000000000000000000000000000..ae7b2bd4a18344262814f0d456125bdd1030aee1
GIT binary patch
literal 5555
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
Bl;{8e

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xxhdpi/ic_fetch.png b/app/src/main/res/drawable-xxhdpi/ic_fetch.png
new file mode 100644
index 0000000000000000000000000000000000000000..df0a63b4b970cffe2dd7d6b34ef9eb39151bdcdc
GIT binary patch
literal 7368
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xxhdpi/ic_more_vdotw.png b/app/src/main/res/drawable-xxhdpi/ic_more_vdotw.png
new file mode 100644
index 0000000000000000000000000000000000000000..9506d1cf781c26d1f8aea920b331190902793b9f
GIT binary patch
literal 630
zcmV-+0*U>JP)<h;3K|Lk000e1NJLTq001xm001xu1^@s6R|5Hm00009a7bBm00027
z000270mdy!jQ{`u8FWQhbW?9;ba!ELWdL_~cP?peYja~^aAhuUa%Y?FJQ@H10s~1z
zK~!jg?V8PM6hRb)PZ`j}RVGV=Yn2#vqxgrSxDCPVBtf4-L>Hp?BtC%n7$OQP6JuQZ
zvyI6rlaQFt#q_wb?5T!RQyJ)QSsePD+sv)5zSGi}6LMS>n2>Z;()nuXqog+>gx@**
ztN=HFb^hfGaJ_WCT7WyiZY2DGUEo&foKb+|z|WfS1HJ=OF5e@r3rSj(G@GD1DQUrF
z>MY=51MMZ3sk4Bi4YbExrp^MsHqfpceLVoPKrf+*w}BI-^F{$4Clv6obk6?*1mHQa
z9|^t(JO!*z|6E6jGm;)iI$JGuCA|zG9KPRvOG`^xa_vGhl9nXRS4&+<uR;i$IsB{u
z_kpd*b6^u#DV?vDD*P~(OXrLN%v5)I7{7py%h!1tU6M4NpzBDw>oRo~Fh5-Kmvb&t
zX8|<O9=J@M1#~lMM+4AFY~l?drB_A|ureh40dTK$&RT%wYO9Rhd3*R=M~P|mx7ERJ
z^GVX{5W-dtzm}GkF(%h8G^hSpWv*IURe!9qmc!2m{lV4?;)AVy;2Gw@mKESh!cpQ;
z>6}qWAMW-r4tL!zG?NLsNgdJ`no|w5r(LGb0(Kf`doELF0q+}V-x+;908_w^geLw5
zr1Z+@0d7<ONB0hJvvkf{fNQ{7B>ZRKirX*e#~zm@U8t5mNP0UKAA5|NKg%}laxZbf
Q_W%F@07*qoM6N<$f}WHVHUIzs

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xxxhdpi/ic_discover_black.png b/app/src/main/res/drawable-xxxhdpi/ic_discover_black.png
new file mode 100644
index 0000000000000000000000000000000000000000..8e4dca2a4fb935967e399f06812dd9822709532d
GIT binary patch
literal 5656
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
b({0BXJ-T(b(M%Vp8^GvJ?v7O}e%<n4zJkW*

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xxxhdpi/ic_fetch.png b/app/src/main/res/drawable-xxxhdpi/ic_fetch.png
new file mode 100644
index 0000000000000000000000000000000000000000..1403a56f170a028a92f654cfb0bf473556881101
GIT binary patch
literal 6308
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable-xxxhdpi/ic_more_vdotw.png b/app/src/main/res/drawable-xxxhdpi/ic_more_vdotw.png
new file mode 100644
index 0000000000000000000000000000000000000000..865698f77beb1714f6ed244945cdb8e018b31f30
GIT binary patch
literal 776
zcmV+j1NZ!iP)<h;3K|Lk000e1NJLTq002M$002M;1^@s6s%dfF00009a7bBm0002&
z0002&0eL8Ky#N3J8FWQhbW?9;ba!ELWdL_~cP?peYja~^aAhuUa%Y?FJQ@H10+mTb
zK~#90?VCSq6hRn=e`8@P6-^Yh@%&R55JW{kKne{OqWB$D2-boK68l7vh#2s5*lBN}
zVsX(TCfX=LEsWxw#XT0gM<lq%{+XHg%*_MW9K7uFzB@a-vpXXtMjIFVg1`Yu*Cb6#
zIw%QAA0<7N^w>G~DYjEIfE&P1iunP|SbGKmxH};6&CFW+dIh)u^ePmf2b{O|_6G2#
zLh^lHTYGx}I8h_{KF34*Z3}$?NoN|wp7mx?K#T(HX%IW%&7y!91^Ct=_KP=*0%8>4
zrBUo~065@njR~-A?d}cWa*YC9wD$H2Fkd10Ics0<kUa{wfbM|AyTDB#`XVhFz~Ou}
zw1HpwuMNxrhphb)i9{li7$Hm=4q%t0DQ&zJ{vhd@bMCu^Pc(oD;88(0*a02_<JO)*
z049Nz66=8Xz@)XWSMobwCi%aMuysa4KJ2Tq5W_9_BuF;ltx4KmF|;dbuXAqQztsjY
zUWrYqdh(Jqmd6GqMgdw4VuLS_V-$b}u|01V1;i-8s!?nyVoZWNl}&<U6+=6c_Wk#h
zVBX$7sS&yuI{9b-<9TyamSv#HC$-^&tQ9U(gk|8EwQmsek+49v@YzfUco6%}TP=ro
zC~I<B`CluNo^P3FK9NWy5{bk=0geLq$+pe(KaVc~_kbhTe!(EyAaNV`J)jNll5L{c
zdK)D2yIz)gYhSMbS1Kgm=aRLz7xJP1u0{cttlhl;oUW04pOc~eV!RVPWfWVA7zNnf
zAU62tu^0vT+8}n#n?(UJ3h=@xc6gxPk(pQ4-rfMFseWkcoVB-CfY}NKxMS@b1Ym~j
zaAXnd!1b6;7Ds3IOS-D;=xi(hdsW%d*+u8v=h#k(QRWW@0afvSaKeWG0000<MNUMn
GLSTZf!C40Y

literal 0
HcmV?d00001

diff --git a/app/src/main/res/drawable/fetch_select_gray.xml b/app/src/main/res/drawable/fetch_select_gray.xml
new file mode 100644
index 00000000..ca0f3d73
--- /dev/null
+++ b/app/src/main/res/drawable/fetch_select_gray.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <shape>
+            <gradient android:angle="270" android:centerColor="@color/fetch_select_gray" android:endColor="@color/fetch_select_gray" android:startColor="@color/fetch_select_gray" />
+            <corners android:radius="8dp" />
+            <padding android:bottom="16dp" android:left="16dp" android:right="16dp" android:top="16dp" />
+        </shape>
+    </item>
+</selector>
\ No newline at end of file
diff --git a/app/src/main/res/layout-land/fetch_select.xml b/app/src/main/res/layout-land/fetch_select.xml
new file mode 100644
index 00000000..6f0f5697
--- /dev/null
+++ b/app/src/main/res/layout-land/fetch_select.xml
@@ -0,0 +1,255 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/fetchSelect"
+    android:layout_height="match_parent"
+    android:layout_width="match_parent"
+    android:background="@color/black_color"
+    android:layout_gravity="center"
+    android:gravity="center"
+    android:padding="16dp"
+    android:orientation="horizontal"
+    android:weightSum="100">
+
+    <LinearLayout
+        android:id="@+id/fetchSelectLeft"
+        android:layout_weight="47"
+        android:orientation="vertical"
+        android:weightSum="100"
+        android:layout_height="match_parent"
+        android:layout_width="0dp">
+
+        <!-- Title -->
+        <TextView
+            android:layout_weight="20"
+            android:id="@+id/fetchSelectTitle"
+            android:textSize="@dimen/popup_title_text_size"
+            android:layout_width="match_parent"
+            android:layout_height="0dp"
+            android:gravity="center|center_vertical"
+            android:textColor="@color/white_color"
+            android:text="Fetch MY_DATA" />
+
+        <!-- Choice buttons -->
+        <LinearLayout
+            android:id="@+id/fetchSelectChoice"
+            android:layout_weight="30"
+            android:layout_height="0dp"
+            android:layout_width="wrap_content"
+            android:gravity="center"
+            android:layout_gravity="center"
+            android:orientation="horizontal">
+
+            <LinearLayout
+                android:id="@+id/fetchSelectChoiceButtons"
+                android:layout_height="@dimen/fetchSelectChoiceButtonHeight"
+                android:layout_width="wrap_content"
+                android:gravity="center"
+                android:layout_gravity="center"
+                android:orientation="horizontal"
+                android:background="@drawable/fetch_select_gray"
+                android:padding="@dimen/fetchSelectChoiceButtonPadding">
+
+                <Button
+                    android:id="@+id/fetchSelectChoiceAfter"
+                    android:layout_width="wrap_content"
+                    android:layout_height="@dimen/pairing_step_button_height"
+                    android:gravity="center_vertical"
+                    android:textSize="@dimen/pairing_step_button_text_size"
+                    android:textColor="@android:color/black"
+                    android:background="@drawable/white_btn"
+                    android:text="After Logging" />
+
+                <Button
+                    android:id="@+id/fetchSelectChoiceDuring"
+                    android:layout_width="wrap_content"
+                    android:layout_height="@dimen/pairing_step_button_height"
+                    android:gravity="center_vertical"
+                    android:textSize="@dimen/pairing_step_button_text_size"
+                    android:textColor="@android:color/black"
+                    android:background="@drawable/fetch_select_gray"
+                    android:text="During Logging" />
+            </LinearLayout>
+        </LinearLayout>
+
+        <View
+            android:layout_weight="10"
+            android:layout_width="match_parent"
+            android:layout_height="0dp" />
+
+        <!-- V2 Only -->
+        <ImageView
+            android:layout_weight="15"
+            android:id="@+id/fetchSelectV2Only"
+            android:layout_width="wrap_content"
+            android:layout_height="0dp"
+            android:layout_gravity="center"
+            android:gravity="center"
+            android:contentDescription="@null"
+            android:src="@drawable/v2only"/>
+
+        <View
+            android:layout_weight="25"
+            android:layout_width="match_parent"
+            android:layout_height="0dp" />
+    </LinearLayout>
+
+    <View
+        android:layout_weight="6"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content" />
+
+    <LinearLayout
+        android:id="@+id/fetchSelectRight"
+        android:layout_weight="47"
+        android:orientation="vertical"
+        android:weightSum="100"
+        android:layout_height="match_parent"
+        android:layout_width="0dp">
+
+        <LinearLayout
+            android:id="@+id/fetchSelectInfo"
+            style="@style/pairing_step_central_image_layout_style"
+            android:orientation="horizontal"
+            android:layout_weight="70">
+
+            <!-- After -->
+            <LinearLayout
+                android:id="@+id/fetchSelectAfter"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:background="@color/black_color"
+                android:layout_gravity="center"
+                android:gravity="center"
+                android:padding="16dp"
+                android:orientation="vertical"
+                android:weightSum="70"
+                android:visibility="gone">
+
+                <!-- Title -->
+                <TextView
+                    android:layout_weight="15"
+                    android:id="@+id/fetchSelectAfterTitle"
+                    android:textSize="@dimen/popup_title_text_size"
+                    android:layout_width="match_parent"
+                    android:layout_height="0dp"
+                    android:gravity="center|center_vertical"
+                    android:textColor="@color/white_color"
+                    android:text="@string/viewPairTriplePromptText"  />
+
+                <LinearLayout
+                    android:id="@+id/fetchSelectAfterGifLayout"
+                    style="@style/pairing_step_central_image_layout_style"
+                    android:layout_weight="55">
+
+                    <pl.droidsonroids.gif.GifImageView
+                        android:id="@+id/fetchSelectAfterGif"
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:layout_margin="@dimen/pairing_step_gif_image_margin"
+                        android:src="@drawable/reset_triple" />
+                </LinearLayout>
+
+            </LinearLayout>
+
+            <!-- During -->
+            <LinearLayout
+                android:id="@+id/fetchSelectDuring"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:background="@color/black_color"
+                android:layout_gravity="center"
+                android:gravity="center"
+                android:paddingHorizontal="16dp"
+                android:orientation="vertical"
+                android:weightSum="70"
+                android:visibility="visible">
+
+                <!-- Title -->
+                <TextView
+                    android:layout_weight="45"
+                    android:id="@+id/fetchSelectDuringText"
+                    android:textSize="@dimen/fetch_during_text_size"
+                    android:layout_width="match_parent"
+                    android:layout_height="0dp"
+                    android:layout_gravity="center|center_vertical"
+                    android:gravity="center_vertical"
+                    android:textColor="@color/white_color"
+                    android:text="@string/fetchSelectDuringPlaceholder"  />
+
+                <LinearLayout
+                    android:layout_weight="25"
+                    android:id="@+id/fetchSelectDuringMoreLayout"
+                    android:layout_width="match_parent"
+                    android:layout_height="0dp"
+                    android:gravity="center"
+                    android:layout_gravity="bottom"
+                    android:weightSum="100">
+
+                    <Button
+                        android:id="@+id/fetchSelectDuringMore"
+                        android:layout_width="wrap_content"
+                        android:layout_height="@dimen/pairing_step_button_height"
+                        android:layout_gravity="center"
+                        android:gravity="center"
+                        android:textSize="@dimen/pairing_step_button_text_size"
+                        android:textColor="@android:color/black"
+                        android:background="@drawable/white_btn"
+                        android:drawableEnd="@drawable/ic_discover_black"
+                        android:drawablePadding="8dp"
+                        android:layout_margin="8dp"
+                        android:text="Find Out More" />
+                </LinearLayout>
+
+            </LinearLayout>
+        </LinearLayout>
+
+        <!-- Confirmation buttons -->
+        <LinearLayout
+            android:id="@+id/fetchSelectButtons"
+            android:layout_weight="25"
+            android:layout_height="0dp"
+            android:layout_width="match_parent"
+            android:gravity="center"
+            android:layout_gravity="bottom"
+            android:weightSum="100"
+            android:orientation="horizontal">
+
+            <Button
+                android:id="@+id/fetchSelectCancel"
+                android:layout_weight="47"
+                android:layout_width="0dp"
+                android:layout_height="@dimen/pairing_step_button_height"
+                android:layout_gravity="bottom"
+                android:gravity="center_vertical"
+                android:textSize="@dimen/pairing_step_button_text_size"
+                android:textColor="@android:color/black"
+                android:background="@drawable/cancel_btn"
+                android:drawableEnd="@drawable/cancel_step_pairing_btn"
+                android:text="@string/txt_cancel_btn" />
+
+            <View
+                android:layout_weight="6"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content" />
+
+            <Button
+                android:id="@+id/fetchSelectOK"
+                android:layout_weight="47"
+                android:layout_width="0dp"
+                android:layout_height="@dimen/pairing_step_button_height"
+                android:layout_gravity="bottom"
+                android:gravity="center_vertical"
+                android:textSize="@dimen/pairing_step_button_text_size"
+                android:textColor="@android:color/black"
+                android:background="@drawable/green_btn"
+                android:drawableEnd="@drawable/ic_done_black"
+                android:text="@string/fetch" />
+        </LinearLayout>
+
+        <View
+            android:layout_weight="5"
+            android:layout_width="match_parent"
+            android:layout_height="0dp" />
+    </LinearLayout>
+</LinearLayout>
diff --git a/app/src/main/res/layout/custom_projects_button.xml b/app/src/main/res/layout/custom_projects_button.xml
deleted file mode 100644
index 7390e2e3..00000000
--- a/app/src/main/res/layout/custom_projects_button.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:id="@+id/createProject"
-    style="@style/custom_button_layout"
-    android:layout_width="0dp"
-    android:layout_weight="@integer/project_my_scripts_button_weight"
-    android:layout_margin="@dimen/custom_button_margin"
-    android:background="@drawable/yellow_btn"
-    android:onClick="onClick"
-    tools:showIn="@layout/activity_projects">
-
-    <ImageView
-        style="@style/custom_button_image"
-        android:contentDescription="@string/txt_my_scripts_btn"
-        android:src="@drawable/ic_my_scripts" />
-
-    <TextView
-        android:id="@+id/custom_button_text"
-        style="@style/custom_button_text"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="@string/my_scripts" />
-</LinearLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/fetch_main.xml b/app/src/main/res/layout/fetch_main.xml
new file mode 100644
index 00000000..942758a6
--- /dev/null
+++ b/app/src/main/res/layout/fetch_main.xml
@@ -0,0 +1,15 @@
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:context="com.samsung.microbit.ui.activity.FetchActivity"
+    android:id="@+id/fetchMain"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/black_color"
+    android:orientation="vertical">
+
+    <include layout="@layout/fetch_web" />
+    <include layout="@layout/fetch_select" />
+    <include layout="@layout/view_projects_pattern" />
+    <include layout="@layout/view_projects_searching" />
+</LinearLayout>
diff --git a/app/src/main/res/layout/fetch_select.xml b/app/src/main/res/layout/fetch_select.xml
new file mode 100644
index 00000000..00cd2815
--- /dev/null
+++ b/app/src/main/res/layout/fetch_select.xml
@@ -0,0 +1,220 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/fetchSelect"
+    android:layout_height="match_parent"
+    android:layout_width="match_parent"
+    android:background="@color/black_color"
+    android:layout_gravity="center"
+    android:gravity="center"
+    android:padding="16dp"
+    android:orientation="vertical"
+    android:weightSum="100">
+
+    <!-- Title -->
+    <TextView
+        android:layout_weight="9"
+        android:id="@+id/fetchSelectTitle"
+        style="@style/pairing_step_header_style"
+        android:text="Fetch MY_DATA" />
+
+    <!-- Choice buttons -->
+    <LinearLayout
+        android:id="@+id/fetchSelectChoice"
+        android:layout_weight="15"
+        android:layout_height="0dp"
+        android:layout_width="wrap_content"
+        android:gravity="center"
+        android:layout_gravity="center"
+        android:orientation="horizontal">
+
+        <LinearLayout
+            android:id="@+id/fetchSelectChoiceButtons"
+            android:layout_height="@dimen/fetchSelectChoiceButtonHeight"
+            android:layout_width="wrap_content"
+            android:gravity="center"
+            android:layout_gravity="center"
+            android:orientation="horizontal"
+            android:background="@drawable/fetch_select_gray"
+            android:padding="@dimen/fetchSelectChoiceButtonPadding">
+
+            <Button
+                android:id="@+id/fetchSelectChoiceAfter"
+                android:layout_width="wrap_content"
+                android:layout_height="match_parent"
+                android:gravity="center_vertical"
+                android:textSize="@dimen/pairing_step_button_text_size"
+                android:textColor="@android:color/black"
+                android:background="@drawable/white_btn"
+                android:text="After Logging" />
+
+            <Button
+                android:id="@+id/fetchSelectChoiceDuring"
+                android:layout_width="wrap_content"
+                android:layout_height="match_parent"
+                android:gravity="center_vertical"
+                android:textSize="@dimen/pairing_step_button_text_size"
+                android:textColor="@android:color/black"
+                android:background="@drawable/fetch_select_gray"
+                android:text="During Logging" />
+        </LinearLayout>
+    </LinearLayout>
+
+    <!-- V2 Only -->
+    <ImageView
+        android:layout_weight="6"
+        android:id="@+id/fetchSelectV2Only"
+        android:layout_width="wrap_content"
+        android:layout_height="0dp"
+        android:layout_gravity="center"
+        android:gravity="center"
+        android:contentDescription="@null"
+        android:src="@drawable/v2only"/>
+
+    <View
+        android:layout_weight="2"
+        android:layout_width="match_parent"
+        android:layout_height="0dp" />
+
+    <LinearLayout
+        android:id="@+id/fetchSelectInfo"
+        style="@style/pairing_step_central_image_layout_style"
+        android:orientation="horizontal"
+        android:layout_weight="56">
+
+        <!-- After -->
+        <LinearLayout
+            android:id="@+id/fetchSelectAfter"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:background="@color/black_color"
+            android:layout_gravity="center"
+            android:gravity="center"
+            android:padding="16dp"
+            android:orientation="vertical"
+            android:weightSum="56"
+            android:visibility="gone">
+
+            <!-- Title -->
+            <TextView
+                android:layout_weight="10"
+                android:id="@+id/fetchSelectAfterTitle"
+                android:textSize="@dimen/popup_title_text_size"
+                android:layout_width="match_parent"
+                android:layout_height="0dp"
+                android:gravity="center|center_vertical"
+                android:textColor="@color/white_color"
+                android:text="@string/viewPairTriplePromptText"  />
+
+            <LinearLayout
+                android:id="@+id/fetchSelectAfterGifLayout"
+                style="@style/pairing_step_central_image_layout_style"
+                android:layout_weight="46">
+
+                <pl.droidsonroids.gif.GifImageView
+                    android:id="@+id/fetchSelectAfterGif"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_margin="@dimen/pairing_step_gif_image_margin"
+                    android:src="@drawable/reset_triple" />
+            </LinearLayout>
+
+        </LinearLayout>
+
+        <!-- During -->
+        <LinearLayout
+            android:id="@+id/fetchSelectDuring"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:background="@color/black_color"
+            android:layout_gravity="center"
+            android:gravity="center"
+            android:paddingHorizontal="16dp"
+            android:orientation="vertical"
+            android:weightSum="56"
+            android:visibility="visible">
+
+            <!-- Text -->
+            <TextView
+                android:layout_weight="46"
+                android:id="@+id/fetchSelectDuringText"
+                android:textSize="@dimen/fetch_during_text_size"
+                android:layout_width="match_parent"
+                android:layout_height="0dp"
+                android:layout_gravity="center|center_vertical"
+                android:gravity="center_vertical"
+                android:textColor="@color/white_color"
+                android:text="@string/fetchSelectDuringPlaceholder"  />
+
+            <LinearLayout
+                android:layout_weight="10"
+                android:id="@+id/fetchSelectDuringMoreLayout"
+                android:layout_width="match_parent"
+                android:layout_height="0dp"
+                style="@style/another_way_button_layout_style">
+
+                <Button
+                    android:id="@+id/fetchSelectDuringMore"
+                    android:layout_width="wrap_content"
+                    android:layout_height="@dimen/pairing_step_button_height"
+                    android:layout_gravity="center"
+                    android:gravity="center"
+                    android:textSize="@dimen/pairing_step_button_text_size"
+                    android:textColor="@android:color/black"
+                    android:background="@drawable/white_btn"
+                    android:drawableEnd="@drawable/ic_discover_black"
+                    android:drawablePadding="8dp"
+                    android:layout_margin="8dp"
+                    android:text="Find Out More" />
+            </LinearLayout>
+
+        </LinearLayout>
+    </LinearLayout>
+
+    <View
+        android:layout_weight="2"
+        android:layout_width="match_parent"
+        android:layout_height="0dp" />
+
+    <!-- Confirmation buttons -->
+    <LinearLayout
+        android:id="@+id/fetchSelectButtons"
+        android:layout_weight="10"
+        android:layout_height="0dp"
+        android:layout_width="match_parent"
+        android:gravity="center"
+        android:layout_gravity="bottom"
+        android:weightSum="100"
+        android:orientation="horizontal">
+
+        <Button
+            android:id="@+id/fetchSelectCancel"
+            android:layout_weight="47"
+            android:layout_width="0dp"
+            android:layout_height="@dimen/pairing_step_button_height"
+            android:gravity="center_vertical"
+            android:textSize="@dimen/pairing_step_button_text_size"
+            android:textColor="@android:color/black"
+            android:background="@drawable/cancel_btn"
+            android:drawableEnd="@drawable/cancel_step_pairing_btn"
+            android:text="@string/txt_cancel_btn" />
+
+        <View
+            android:layout_weight="6"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content" />
+
+        <Button
+            android:id="@+id/fetchSelectOK"
+            android:layout_weight="47"
+            android:layout_width="0dp"
+            android:layout_height="@dimen/pairing_step_button_height"
+            android:gravity="center_vertical"
+            android:textSize="@dimen/pairing_step_button_text_size"
+            android:textColor="@android:color/black"
+            android:background="@drawable/green_btn"
+            android:drawableEnd="@drawable/ic_done_black"
+            android:text="@string/fetch" />
+    </LinearLayout>
+
+</LinearLayout>
diff --git a/app/src/main/res/layout/fetch_web.xml b/app/src/main/res/layout/fetch_web.xml
new file mode 100644
index 00000000..08cfb67c
--- /dev/null
+++ b/app/src/main/res/layout/fetch_web.xml
@@ -0,0 +1,64 @@
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/fetchWeb"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:padding="0dp"
+    android:orientation="vertical">
+
+    <LinearLayout
+        android:id="@+id/fetchWebBar"
+        android:layout_width="match_parent"
+        android:layout_height="?attr/actionBarSize"
+        android:background="@color/main_gray_color"
+        android:elevation="@dimen/activity_vertical_margin">
+
+        <!-- back button-->
+        <ImageButton
+            android:id="@+id/fetchWebBarBack"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center_vertical"
+            android:background="@android:color/transparent"
+            android:contentDescription="@string/back"
+            android:nextFocusDown="@id/fetchWebBarTitle"
+            android:padding="@dimen/app_bar_back_btn_padding"
+            android:src="@drawable/ic_back_arrow" />
+
+        <!-- divider -->
+        <View
+            android:layout_width="@dimen/app_bar_divider_width"
+            android:layout_height="match_parent"
+            android:layout_marginBottom="@dimen/app_bar_small_divider_margin"
+            android:layout_marginTop="@dimen/app_bar_small_divider_margin"
+            android:alpha="@dimen/app_bar_small_divider_alpha"
+            android:background="@android:color/white" />
+
+        <!-- title-->
+        <TextView
+            android:id="@+id/fetchWebBarTitle"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center_vertical"
+            android:layout_weight="1"
+            android:contentDescription="@string/my_data"
+            android:focusable="true"
+            android:focusableInTouchMode="true"
+            android:gravity="center"
+            android:text="@string/my_data"
+            android:textSize="@dimen/app_bar_title_text_size"
+            android:textColor="@android:color/white" />
+
+    </LinearLayout>
+
+    <WebView
+        android:id="@+id/fetchWebView"
+        android:background="@color/cancel_button"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:layout_marginBottom="0dp"
+        android:hardwareAccelerated="true"
+        android:windowSoftInputMode="adjustResize" />
+
+</LinearLayout>
diff --git a/app/src/main/res/layout/project_items.xml b/app/src/main/res/layout/project_items.xml
index 042a0e42..581816a8 100644
--- a/app/src/main/res/layout/project_items.xml
+++ b/app/src/main/res/layout/project_items.xml
@@ -13,7 +13,6 @@
         android:drawableEnd="@drawable/ic_arrow_down"
         android:gravity="start|center_vertical"
         android:longClickable="true"
-        android:textAllCaps="false"
         android:textColor="@android:color/white"
         android:textSize="@dimen/project_items_text_size" />
 
diff --git a/app/src/main/res/layout/projects_app_bar.xml b/app/src/main/res/layout/projects_app_bar.xml
index dec2a374..ac876463 100644
--- a/app/src/main/res/layout/projects_app_bar.xml
+++ b/app/src/main/res/layout/projects_app_bar.xml
@@ -53,7 +53,7 @@
         android:layout_height="wrap_content"
         android:layout_gravity="center_vertical"
         android:layout_weight="1"
-        android:nextFocusDown="@+id/appNameButton"
+        android:nextFocusDown="@+id/projectMoreButton"
         android:orientation="vertical">
 
         <TextView
@@ -76,5 +76,18 @@
     <!-- Small divider -->
     <include layout="@layout/app_bar_small_divider" />
 
+    <!-- more button-->
+    <ImageButton
+        android:id="@+id/projectMoreButton"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center_vertical"
+        android:background="@android:color/transparent"
+        android:contentDescription="@string/more"
+        android:nextFocusDown="@id/appNameButton"
+        android:onClick="onClick"
+        android:padding="@dimen/app_bar_back_btn_padding"
+        android:src="@drawable/ic_more_vdotw" />
+
     <!-- connected device status -->
 </LinearLayout>
diff --git a/app/src/main/res/layout/view_projects_projects.xml b/app/src/main/res/layout/view_projects_projects.xml
index 6e5707a0..7d4a17d1 100644
--- a/app/src/main/res/layout/view_projects_projects.xml
+++ b/app/src/main/res/layout/view_projects_projects.xml
@@ -31,10 +31,9 @@
 
     </LinearLayout>
 
-    <!-- View my scripts -->
     <include layout="@layout/view_divider" />
 
-    <!-- My Scripts button -->
+    <!-- Bottom panel -->
     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
@@ -42,6 +41,27 @@
         android:gravity="center_horizontal"
         android:weightSum="2">
 
-        <include layout="@layout/custom_projects_button" />
+        <!-- Fetch button -->
+        <LinearLayout
+            android:id="@+id/projectFetch"
+            style="@style/custom_button_layout"
+            android:layout_width="0dp"
+            android:layout_weight="@integer/project_fetch_button_weight"
+            android:layout_margin="@dimen/project_fetch_button_margin"
+            android:background="@drawable/black_btn"
+            android:onClick="onClick">
+
+            <ImageView
+                style="@style/custom_button_image"
+                android:contentDescription="@string/desc_fetch"
+                android:src="@drawable/ic_fetch" />
+
+            <TextView
+                android:id="@+id/projectFetchText"
+                style="@style/fetch_button_text"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="@string/fetch_my_data" />
+        </LinearLayout>
     </LinearLayout>
 </LinearLayout>
diff --git a/app/src/main/res/values-land/dimens.xml b/app/src/main/res/values-land/dimens.xml
index e538a406..f240778a 100644
--- a/app/src/main/res/values-land/dimens.xml
+++ b/app/src/main/res/values-land/dimens.xml
@@ -139,11 +139,15 @@
     <dimen name="popup_gif_size">110dp</dimen>
 
     <!-- Project screen -->
-    <integer name="project_my_scripts_button_weight">1</integer>
+    <integer name="project_fetch_button_weight">1</integer>
     <dimen name="project_item_lists_indentation">8dp</dimen>
     <dimen name="project_items_layout_padding">16dp</dimen>
     <dimen name="project_items_layout_margin_top">8dp</dimen>
-    <dimen name="custom_button_margin">8dp</dimen>
+    <dimen name="project_fetch_button_margin">8dp</dimen>
     <dimen name="project_item_buttons_size">57dp</dimen>
+
+    <dimen name="fetch_during_text_size">16sp</dimen>
+    <dimen name="fetchSelectChoiceButtonHeight">66dp</dimen>
+    <dimen name="fetchSelectChoiceButtonPadding">4dp</dimen>
 </resources>
 
diff --git a/app/src/main/res/values-sw360dp-land/dimens.xml b/app/src/main/res/values-sw360dp-land/dimens.xml
index b497f438..fdfa2d27 100644
--- a/app/src/main/res/values-sw360dp-land/dimens.xml
+++ b/app/src/main/res/values-sw360dp-land/dimens.xml
@@ -110,4 +110,6 @@
     <dimen name="popup_linear_progress_bar_margin">18dp</dimen>
     <dimen name="popup_round_ok_button_size">66dp</dimen>
     <dimen name="popup_gif_size">128dp</dimen>
+
+    <dimen name="fetch_during_text_size">16sp</dimen>
 </resources>
diff --git a/app/src/main/res/values-sw360dp-port/dimens.xml b/app/src/main/res/values-sw360dp-port/dimens.xml
index 8aa96c68..64d7b9de 100644
--- a/app/src/main/res/values-sw360dp-port/dimens.xml
+++ b/app/src/main/res/values-sw360dp-port/dimens.xml
@@ -90,4 +90,6 @@
 	<!-- Default screen margins, per the Android Design guidelines. -->
 	<dimen name="fab_margin">16dp</dimen>
 
+	<dimen name="fetch_during_text_size">16dp</dimen>
+
 </resources>
diff --git a/app/src/main/res/values-sw600dp-land/dimens.xml b/app/src/main/res/values-sw600dp-land/dimens.xml
index 336ab65b..1c13b08c 100644
--- a/app/src/main/res/values-sw600dp-land/dimens.xml
+++ b/app/src/main/res/values-sw600dp-land/dimens.xml
@@ -126,6 +126,10 @@
     <!-- Project screen -->
     <dimen name="project_item_lists_indentation">16dp</dimen>
     <dimen name="project_items_layout_padding">32dp</dimen>
-    <dimen name="custom_button_margin">16dp</dimen>
+    <dimen name="project_fetch_button_margin">16dp</dimen>
     <dimen name="custom_button_height">72dp</dimen>
+
+    <dimen name="fetch_during_text_size">22sp</dimen>
+    <dimen name="fetchSelectChoiceButtonHeight">80dp</dimen>
+    <dimen name="fetchSelectChoiceButtonPadding">4dp</dimen>
 </resources>
diff --git a/app/src/main/res/values-sw600dp-port/dimens.xml b/app/src/main/res/values-sw600dp-port/dimens.xml
index 77bee2ae..fef4f1b8 100644
--- a/app/src/main/res/values-sw600dp-port/dimens.xml
+++ b/app/src/main/res/values-sw600dp-port/dimens.xml
@@ -148,4 +148,8 @@
 
     <dimen name="pairing_searching_step_cycle_progress_bar_size">100dp</dimen>
 
+    <dimen name="fetch_during_text_size">22sp</dimen>
+    <dimen name="fetchSelectChoiceButtonHeight">76dp</dimen>
+    <dimen name="fetchSelectChoiceButtonPadding">4dp</dimen>
+
 </resources>
diff --git a/app/src/main/res/values-sw720dp-land/dimens.xml b/app/src/main/res/values-sw720dp-land/dimens.xml
index f04bc501..397c8ad8 100644
--- a/app/src/main/res/values-sw720dp-land/dimens.xml
+++ b/app/src/main/res/values-sw720dp-land/dimens.xml
@@ -103,4 +103,6 @@
     <dimen name="popup_gif_size">220dp</dimen>
     <dimen name="popup_linear_progress_bar_margin">32dp</dimen>
     <dimen name="popup_title_padding_bottom">18dp</dimen>
+
+    <dimen name="fetch_during_text_size">24dp</dimen>
 </resources>
diff --git a/app/src/main/res/values-sw720dp-port/dimens.xml b/app/src/main/res/values-sw720dp-port/dimens.xml
index fb9171b1..ff9a2d26 100644
--- a/app/src/main/res/values-sw720dp-port/dimens.xml
+++ b/app/src/main/res/values-sw720dp-port/dimens.xml
@@ -101,4 +101,6 @@
 
     <dimen name="pairing_step_image_width">360dp</dimen>
     <dimen name="pairing_step_image_height">270dp</dimen>
+
+    <dimen name="fetch_during_text_size">24dp</dimen>
 </resources>
diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml
index b74a2e26..7988cbf7 100644
--- a/app/src/main/res/values/colors.xml
+++ b/app/src/main/res/values/colors.xml
@@ -19,6 +19,7 @@
     <color name="grey_trans_20_opacity_container_highlight">#33424242</color>
     <color name="ok_button_up">#00EC00</color>
     <color name="ok_button_down">#3A871F</color>
+    <color name="fetch_select_gray">#666666</color>
 
     <color name="cancel_button_up">#FD645B</color>
     <color name="cancel_button_down">#AA6666</color>
diff --git a/app/src/main/res/values/dimens.xml b/app/src/main/res/values/dimens.xml
index 57148dd9..8066dca5 100644
--- a/app/src/main/res/values/dimens.xml
+++ b/app/src/main/res/values/dimens.xml
@@ -37,14 +37,14 @@
     <dimen name="custom_button_start_margin">8dp</dimen>
     <dimen name="custom_button_end_margin">8dp</dimen>
     <dimen name="custom_button_image_margin">0dp</dimen>
-    <dimen name="custom_button_margin">16dp</dimen>
+    <dimen name="project_fetch_button_margin">16dp</dimen>
     <dimen name="custom_button_height">52dp</dimen>
     <dimen name="image_delete_button_margin_end">8dp</dimen>
     <dimen name="project_item_buttons_size">48dp</dimen>
     <dimen name="project_items_layout_padding">16dp</dimen>
     <dimen name="project_items_layout_margin_top">16dp</dimen>
     <dimen name="project_items_image_padding">6dp</dimen>
-    <integer name="project_my_scripts_button_weight">2</integer>
+    <integer name="project_fetch_button_weight">2</integer>
     <dimen name="project_item_action_bar_layout_margin">14dp</dimen>
     <dimen name="project_items_text_size">18sp</dimen>
 
@@ -130,5 +130,8 @@
     <dimen name="splash_screen_logo_width">200dp</dimen>
     <dimen name="splash_screen_logo_height">32dp</dimen>
 
+    <dimen name="fetch_during_text_size">18sp</dimen>
+    <dimen name="fetchSelectChoiceButtonHeight">58dp</dimen>
+    <dimen name="fetchSelectChoiceButtonPadding">4dp</dimen>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 5a4c437b..12f240bd 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -30,6 +30,7 @@
     <string name="terms_of_use_url" translatable="false">http://microbit.org/terms-of-use</string>
     <string name="about_url" translatable="false">http://microbit.org/about</string>
     <string name="feedback_email_address" translatable="false">rohit.ail@samsung.com</string>
+    <string name="fetchDuringFindOutMoreUrl" translatable="false">https://microbit.org/get-started/user-guide/mobile</string>
 
 
     <string name="user_agent" translatable="false">SamsungBrowser/microbit Profile/OTA-DFU1.0</string>
@@ -312,7 +313,7 @@
     <string name="nav_draw_terms_conditions"><![CDATA[Terms & Conditions]]></string>
     <string name="nav_draw_send_feedback">Send us your feedback</string>
     <string name="nav_draw_share_statistics">Share Statistics</string>
-    <string name="txt_my_scripts_btn">My Scripts</string>
+    <string name="desc_fetch">Fetch MY_DATA (V2 only)</string>
     <string name="desc_nav_drawer_menu">Close Menu</string>
     <string name="desc_share_statistics_description">This information will only be used to analyse and improve the services offered through this app. For information, see our privacy policy </string>
     <string name="txt_pair_btn">Pair</string>
@@ -401,5 +402,26 @@
     <string name="btn_continue">Continue</string>
     <string name="paired">paired</string>
     <string name="not_paired">not paired</string>
+    <string name="fetch_my_data">Fetch MY_DATA (V2 only)</string>
+    <string name="more">More</string>
+    <string name="fetch">Fetch</string>
+    <string name="fetchSelectDuringHtml"><![CDATA[<div><div>To fetch a preview during logging, without resetting your micro:bit:</div><ul><li>Include the Bluetooth extension in your program</li><li>Pair the micro:bit before logging.</li></ul></div>]]></string>
+    <string name="fetchSelectDuringPlaceholder">To fetch a preview during logging, without resetting your micro:bit:\n\nInclude the Bluetooth extension in your program\n\nPair the micro:bit before logging.</string>
+    <string name="fetchSelectDuring0">To fetch a preview during logging, without resetting your micro:bit:</string>
+    <string name="fetchSelectDuring1">Include the Bluetooth extension in your program</string>
+    <string name="fetchSelectDuring2">Pair the micro:bit before logging.</string>
+    <string name="fetchFailed">Failed to fetch MY_DATA</string>
+    <string name="fetching">Fetching MY_DATA</string>
+    <string name="back">Back</string>
+    <string name="my_data">My Data</string>
+    <string name="fetch_connection_failed">Connection failed</string>
+    <string name="fetch_connection_lost">Connection lost</string>
+    <string name="fetch_connection_broken">Connection broken</string>
+    <string name="fetch_update_the_project_to_add_the_bluetooth_service">Update the project to add the Bluetooth service</string>
+    <string name="fetch_connection_error">Connection error</string>
+    <string name="fetch_no_data_in_micro_bit">No data in micro:bit</string>
+    <string name="fetch_out_of_memory">Out of memory</string>
+    <string name="fetch_failed_to_create_my_data_htm">Failed to create MY_DATA.HTM</string>
+    <string name="fetch_works_with_micro_bit_v2_only">Works with micro:bit V2 only</string>
 </resources>
 
diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml
index 190ad346..984753b3 100644
--- a/app/src/main/res/values/styles.xml
+++ b/app/src/main/res/values/styles.xml
@@ -104,6 +104,13 @@
         <item name="android:textAppearance">?android:textAppearance</item>
     </style>
 
+    <!-- Fetch button -->
+    <style name="fetch_button_text">
+        <item name="android:textSize">@dimen/p1_font_size</item>
+        <item name="android:textColor">@android:color/white</item>
+        <item name="android:textAppearance">?android:textAppearance</item>
+    </style>
+
     <!-- Edit project button -->
     <style name="edit_project_text">
         <item name="android:textSize">@dimen/p1_font_size</item>