stack size for background thread set to 5MB (monero dafault)

so no need to use heap for slow_hash
recompiled monero without USE_HEAP

app/app.iml

@@ -89,7 +89,6 @@
       <sourceFolder url="file://$MODULE_DIR$/src/test/shaders" isTestSource="true" />
       <excludeFolder url="file://$MODULE_DIR$/build/intermediates/assets" />
       <excludeFolder url="file://$MODULE_DIR$/build/intermediates/blame" />
-      <excludeFolder url="file://$MODULE_DIR$/build/intermediates/builds" />
       <excludeFolder url="file://$MODULE_DIR$/build/intermediates/classes" />
       <excludeFolder url="file://$MODULE_DIR$/build/intermediates/cmake" />
       <excludeFolder url="file://$MODULE_DIR$/build/intermediates/incremental" />

app/src/main/java/com/m2049r/xmrwallet/service/MoneroHandlerThread.java

@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ * Copyright (c) 2017 m2049r
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.m2049r.xmrwallet.service;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Process;
+
+
+/**
+ * Handy class for starting a new thread that has a looper. The looper can then be
+ * used to create handler classes. Note that start() must still be called.
+ * The started Thread has a stck size of STACK_SIZE (=3MB)
+ */
+public class MoneroHandlerThread extends Thread {
+    // from src/cryptonote_config.h
+    static public final long THREAD_STACK_SIZE = 5 * 1024 * 1024;
+    int mPriority;
+    int mTid = -1;
+    Looper mLooper;
+
+    public MoneroHandlerThread(String name) {
+        super(null, null, name, THREAD_STACK_SIZE);
+        mPriority = Process.THREAD_PRIORITY_DEFAULT;
+    }
+
+    /**
+     * Constructs a MoneroHandlerThread.
+     *
+     * @param name
+     * @param priority The priority to run the thread at. The value supplied must be from
+     *                 {@link android.os.Process} and not from java.lang.Thread.
+     */
+    public MoneroHandlerThread(String name, int priority) {
+        super(null, null, name, THREAD_STACK_SIZE);
+        mPriority = priority;
+    }
+
+    /**
+     * Call back method that can be explicitly overridden if needed to execute some
+     * setup before Looper loops.
+     */
+
+    protected void onLooperPrepared() {
+    }
+
+    @Override
+    public void run() {
+        mTid = Process.myTid();
+        Looper.prepare();
+        synchronized (this) {
+            mLooper = Looper.myLooper();
+            notifyAll();
+        }
+        Process.setThreadPriority(mPriority);
+        onLooperPrepared();
+        Looper.loop();
+        mTid = -1;
+    }
+
+    /**
+     * This method returns the Looper associated with this thread. If this thread not been started
+     * or for any reason is isAlive() returns false, this method will return null. If this thread
+     * has been started, this method will block until the looper has been initialized.
+     *
+     * @return The looper.
+     */
+    public Looper getLooper() {
+        if (!isAlive()) {
+            return null;
+        }
+
+        // If the thread has been started, wait until the looper has been created.
+        synchronized (this) {
+            while (isAlive() && mLooper == null) {
+                try {
+                    wait();
+                } catch (InterruptedException e) {
+                }
+            }
+        }
+        return mLooper;
+    }
+
+    /**
+     * Quits the handler thread's looper.
+     * <p>
+     * Causes the handler thread's looper to terminate without processing any
+     * more messages in the message queue.
+     * </p><p>
+     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
+     * For example, the {@link Handler#sendMessage(Message)} method will return false.
+     * </p><p class="note">
+     * Using this method may be unsafe because some messages may not be delivered
+     * before the looper terminates.  Consider using {@link #quitSafely} instead to ensure
+     * that all pending work is completed in an orderly manner.
+     * </p>
+     *
+     * @return True if the looper looper has been asked to quit or false if the
+     * thread had not yet started running.
+     * @see #quitSafely
+     */
+    public boolean quit() {
+        Looper looper = getLooper();
+        if (looper != null) {
+            looper.quit();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Quits the handler thread's looper safely.
+     * <p>
+     * Causes the handler thread's looper to terminate as soon as all remaining messages
+     * in the message queue that are already due to be delivered have been handled.
+     * Pending delayed messages with due times in the future will not be delivered.
+     * </p><p>
+     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
+     * For example, the {@link Handler#sendMessage(Message)} method will return false.
+     * </p><p>
+     * If the thread has not been started or has finished (that is if
+     * {@link #getLooper} returns null), then false is returned.
+     * Otherwise the looper is asked to quit and true is returned.
+     * </p>
+     *
+     * @return True if the looper looper has been asked to quit or false if the
+     * thread had not yet started running.
+     */
+    public boolean quitSafely() {
+        Looper looper = getLooper();
+        if (looper != null) {
+            looper.quitSafely();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Returns the identifier of this thread. See Process.myTid().
+     */
+    public int getThreadId() {
+        return mTid;
+    }
+}

app/src/main/java/com/m2049r/xmrwallet/service/WalletService.java

@@ -21,15 +21,14 @@ import android.content.Intent;
 import android.os.Binder;
 import android.os.Bundle;
 import android.os.Handler;
-import android.os.HandlerThread;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.Message;
 import android.os.Process;
 import android.util.Log;
-import android.widget.Toast;
 
 import com.m2049r.xmrwallet.R;
+import com.m2049r.xmrwallet.model.TransactionHistory;
 import com.m2049r.xmrwallet.model.Wallet;
 import com.m2049r.xmrwallet.model.WalletListener;
 import com.m2049r.xmrwallet.model.WalletManager;
@@ -131,12 +130,19 @@ public class WalletService extends Service {
 
         public void refreshed() {
             if (wallet == null) throw new IllegalStateException("No wallet!");
-            Log.d(TAG, "refreshed() " + wallet.getBalance() + " sync=" + wallet.isSynchronized() + " with observer " + observer);
+            Log.d(TAG, "refreshed() " + wallet.getName() + " " + wallet.getBalance() + " sync=" + wallet.isSynchronized() + " with observer " + observer);
             if (updated) {
                 if (observer != null) {
+                    Log.d(TAG, "refreshed() A");
                     updateDaemonState(wallet, 0);
-                    wallet.getHistory().refresh();
+                    Log.d(TAG, "refreshed() B");
+                    TransactionHistory history = wallet.getHistory();
+                    Log.d(TAG, "refreshed() C " + history.getCount());
+                    history.refresh();
+                    Log.d(TAG, "refreshed() D " + history.getCount());
+                    Log.d(TAG, "refreshed() E");
                     observer.onRefreshed(wallet, true);
+                    Log.d(TAG, "refreshed() D");
                     updated = false;
                 }
             }
@@ -267,7 +273,7 @@ public class WalletService extends Service {
 
         // We are using a HandlerThread and a Looper to avoid loading and closing
         // concurrency
-        HandlerThread thread = new HandlerThread("WalletService",
+        MoneroHandlerThread thread = new MoneroHandlerThread("WalletService",
                 Process.THREAD_PRIORITY_BACKGROUND);
         thread.start();
 
@@ -344,19 +350,12 @@ public class WalletService extends Service {
             Wallet aWallet = loadWallet(walletName, walletPassword);
             listener = new MyWalletListener(aWallet);
             listener.start();
-            showProgress(95);
-        }
-        Log.d(TAG, "start() notify obeserver first time");
-        if (observer != null) {
-            Wallet myWallet = getWallet();
-            showProgress(getString(R.string.status_wallet_connecting));
-            showProgress(-1);
-            updateDaemonState(myWallet, 0);
-            myWallet.getHistory().refresh();
-            if (observer != null) { // TODO this could still happen - need to sync threads
-                observer.onRefreshed(myWallet, true);
-            }
+            showProgress(100);
         }
+        showProgress(getString(R.string.status_wallet_connecting));
+        showProgress(-1);
+        // if we try to refresh the history here we get occasional segfaults!
+        // doesnt matter since we update as soon as we get a new block anyway
         Log.d(TAG, "start() done");
     }