QA@IT
«回答へ戻る

記述ミスを修正。

20
 }
 ```
 
-```Scala
+```scala
 class ScalaSub2[T] extends JavaBase[T] {
   override def method1(param: T) {
   }

実行環境が異なるので大丈夫かわかりませんが以下のような書き方で正常に動作しています。

Scala 2.9.1
sbt 0.11.3
android-plugin 0.6.1

import _root_.android.app.Activity
import _root_.android.os.Bundle
import _root_.android.os.AsyncTask
import _root_.android.util.Log

class MainActivity extends Activity with TypedActivity {
  override def onCreate(bundle: Bundle) {
    super.onCreate(bundle)
    setContentView(R.layout.main)

    findView(TR.textview).setText("hello, world!")

    val values:Seq[Int] = 1 to 10

    task.execute(values: _*)
  }
  private lazy val task = new TestTask

  override def onDestroy() {
    super.onDestroy()

    task.cancel(true)
  }

  abstract class MyAsyncTask[A, B, C] extends AsyncTask[A, B, C] {
    override protected def doInBackground(values: A*): C = {
      doInBackgroundImpl(values: _*)
    }
    protected def doInBackgroundImpl(values: A*): C
    override protected def onProgressUpdate(progress: B*) = {
      onProgressUpdateImpl(progress: _*)
    }
    protected def onProgressUpdateImpl(progress: B*)
  }

  class TestTask extends MyAsyncTask[Int, Int, Int] {
    override protected def onPreExecute() {
      Log.d("SampleProject", "onPreExecute()")
    }

    override protected def doInBackgroundImpl(values: Int*): Int = {
      Log.d("SampleProject", "doInBackground()")
      values.foreach {v =>
        Log.d("SampleProject", v.toString)
        publishProgress(v)
        Thread.sleep(1000)
      }
      values.foldLeft(0)(_ + _)
    }

    override protected def onProgressUpdateImpl(progress: Int*) {
      Log.d("SampleProject", "onProgressUpdate()")
      progress.foreach(v => Log.d("SampleProject", v.toString))
      findView(TR.textview).setText(progress.toString)
    }

    override protected def onPostExecute(result: Int) {
      Log.d("SampleProject", "onPostExecute()")
      Log.d("SampleProject", result.toString)
    }
  }
}

上記の書き方は色々試行錯誤していてたまたま動いたもので理由などはよくわからず、漠然と逆コンパイルすれば何かわかるかなと思っていたぐらいなのですが、ご質問いただいたので実際に逆コンパイルで色々試してみました。

以下のように逆コンパイルのテスト用ににジェネリクスを使用したJavaクラスと
型をStringに設定したサブクラスをJavaとScalaで作成、
そして今回の解決策とした型を確定させないScalaのサブクラスを
定義しました。

public class JavaBase<T> {
  public void method1(T param) {
  }
  public void method2(T... params) {
  }
}
public class JavaSub extends JavaBase<String> {
  public void method1(String param) {
  }
  public void method2(String... params) {
  }
}
class ScalaSub extends JavaBase[String] {
  override def method1(param: String) {
  }
  override def method2(params: String*) {
  }
}
class ScalaSub2[T] extends JavaBase[T] {
  override def method1(param: T) {
  }
  override def method2(params: T*) {
  }
}

上記の各クラスを一旦classファイルにコンパイルし、逆コンパイルすると
以下のようになります。

public class JavaBase
{
    public void method1(Object obj)
    {
    }

    public transient void method2(Object aobj[])
    {
    }
}
public class JavaSub extends JavaBase
{
    public volatile void method1(Object obj)
    {
        method1((String)obj);
    }

    public void method1(String s)
    {
    }

    public volatile void method2(Object aobj[])
    {
        method2((String[])aobj);
    }

    public transient void method2(String as[])
    {
    }
}
public class ScalaSub extends JavaBase
    implements ScalaObject
{
    public volatile void method1(Object param)
    {
        method1((String)param);
    }

    public void method1(String s)
    {
    }

    public void method2(String params[])
    {
        method2(((Seq) (Predef$.MODULE$.wrapRefArray((Object[])params))));
    }

    public void method2(Seq seq)
    {
    }
}
public class ScalaSub2 extends JavaBase
    implements ScalaObject
{
    public void method1(Object obj)
    {
    }

    public void method2(Object params[])
    {
        method2(((Seq) (Predef$.MODULE$.genericWrapArray(((Object) (params))))));
    }

    public void method2(Seq seq)
    {
    }
}

ざっと見ていただければわかると思いますが、ジェネリクスで定義した型(T型)はObject型に
置き換えられ、その中で確定させた型を引数とするメソッドを実行するようになっています。
また可変長引数はObject型の配列となっています。
ところが今回問題となっている型を確定させたScalaのサブクラス(ScalaSub)では
Object型の配列を引数とするメソッドが生成されていません
(かわりにStringの配列を引数とするメソッドとなっています)。

ここからは推測となりますが、仮想マシンはジェネリクスな可変長引数のメソッドを
実行する場合は、Object型の配列を引数とするメソッドを探して実行するはずのところ
Scalaのサブクラスにはそのようなメソッドがないため、実行エラーとなっていると考えられます。
可変長引数でない場合は、ScalaのサブクラスでもきちんとObject型引数メソッド内で
String型引数メソッドを実行するようになっているため正常に実行出来ているようです。

実行環境が異なるので大丈夫かわかりませんが以下のような書き方で正常に動作しています。

Scala 2.9.1
sbt 0.11.3
android-plugin 0.6.1

```scala
import _root_.android.app.Activity
import _root_.android.os.Bundle
import _root_.android.os.AsyncTask
import _root_.android.util.Log

class MainActivity extends Activity with TypedActivity {
  override def onCreate(bundle: Bundle) {
    super.onCreate(bundle)
    setContentView(R.layout.main)

    findView(TR.textview).setText("hello, world!")

    val values:Seq[Int] = 1 to 10

    task.execute(values: _*)
  }
  private lazy val task = new TestTask

  override def onDestroy() {
    super.onDestroy()

    task.cancel(true)
  }

  abstract class MyAsyncTask[A, B, C] extends AsyncTask[A, B, C] {
    override protected def doInBackground(values: A*): C = {
      doInBackgroundImpl(values: _*)
    }
    protected def doInBackgroundImpl(values: A*): C
    override protected def onProgressUpdate(progress: B*) = {
      onProgressUpdateImpl(progress: _*)
    }
    protected def onProgressUpdateImpl(progress: B*)
  }
  
  class TestTask extends MyAsyncTask[Int, Int, Int] {
    override protected def onPreExecute() {
      Log.d("SampleProject", "onPreExecute()")
    }

    override protected def doInBackgroundImpl(values: Int*): Int = {
      Log.d("SampleProject", "doInBackground()")
      values.foreach {v =>
        Log.d("SampleProject", v.toString)
        publishProgress(v)
        Thread.sleep(1000)
      }
      values.foldLeft(0)(_ + _)
    }

    override protected def onProgressUpdateImpl(progress: Int*) {
      Log.d("SampleProject", "onProgressUpdate()")
      progress.foreach(v => Log.d("SampleProject", v.toString))
      findView(TR.textview).setText(progress.toString)
    }

    override protected def onPostExecute(result: Int) {
      Log.d("SampleProject", "onPostExecute()")
      Log.d("SampleProject", result.toString)
    }
  }
}
```


上記の書き方は色々試行錯誤していてたまたま動いたもので理由などはよくわからず、漠然と逆コンパイルすれば何かわかるかなと思っていたぐらいなのですが、ご質問いただいたので実際に逆コンパイルで色々試してみました。


以下のように逆コンパイルのテスト用ににジェネリクスを使用したJavaクラスと
型をStringに設定したサブクラスをJavaとScalaで作成、
そして今回の解決策とした型を確定させないScalaのサブクラスを
定義しました。

```java
public class JavaBase<T> {
  public void method1(T param) {
  }
  public void method2(T... params) {
  }
}
```

```java
public class JavaSub extends JavaBase<String> {
  public void method1(String param) {
  }
  public void method2(String... params) {
  }
}
```

```scala
class ScalaSub extends JavaBase[String] {
  override def method1(param: String) {
  }
  override def method2(params: String*) {
  }
}
```

```scala
class ScalaSub2[T] extends JavaBase[T] {
  override def method1(param: T) {
  }
  override def method2(params: T*) {
  }
}
```

上記の各クラスを一旦classファイルにコンパイルし、逆コンパイルすると
以下のようになります。

```java
public class JavaBase
{
    public void method1(Object obj)
    {
    }

    public transient void method2(Object aobj[])
    {
    }
}
```

```java
public class JavaSub extends JavaBase
{
    public volatile void method1(Object obj)
    {
        method1((String)obj);
    }

    public void method1(String s)
    {
    }

    public volatile void method2(Object aobj[])
    {
        method2((String[])aobj);
    }

    public transient void method2(String as[])
    {
    }
}
```

```java
public class ScalaSub extends JavaBase
    implements ScalaObject
{
    public volatile void method1(Object param)
    {
        method1((String)param);
    }

    public void method1(String s)
    {
    }

    public void method2(String params[])
    {
        method2(((Seq) (Predef$.MODULE$.wrapRefArray((Object[])params))));
    }

    public void method2(Seq seq)
    {
    }
}
```

```java
public class ScalaSub2 extends JavaBase
    implements ScalaObject
{
    public void method1(Object obj)
    {
    }

    public void method2(Object params[])
    {
        method2(((Seq) (Predef$.MODULE$.genericWrapArray(((Object) (params))))));
    }

    public void method2(Seq seq)
    {
    }
}
```
ざっと見ていただければわかると思いますが、ジェネリクスで定義した型(T型)はObject型に
置き換えられ、その中で確定させた型を引数とするメソッドを実行するようになっています。
また可変長引数はObject型の配列となっています。
ところが今回問題となっている型を確定させたScalaのサブクラス(ScalaSub)では
Object型の配列を引数とするメソッドが生成されていません
(かわりにStringの配列を引数とするメソッドとなっています)。

ここからは推測となりますが、仮想マシンはジェネリクスな可変長引数のメソッドを
実行する場合は、Object型の配列を引数とするメソッドを探して実行するはずのところ
Scalaのサブクラスにはそのようなメソッドがないため、実行エラーとなっていると考えられます。
可変長引数でない場合は、ScalaのサブクラスでもきちんとObject型引数メソッド内で
String型引数メソッドを実行するようになっているため正常に実行出来ているようです。

逆コンパイルを試してみた結果を追記。

20
 sbt 0.11.3
 android-plugin 0.6.1
 
-```
+```scala
 import _root_.android.app.Activity
 import _root_.android.os.Bundle
 import _root_.android.os.AsyncTask
   }
 }
 ```
+
+
+上記の書き方は色々試行錯誤していてたまたま動いたもので理由などはよくわからず、漠然と逆コンパイルすれば何かわかるかなと思っていたぐらいなのですが、ご質問いただいたので実際に逆コンパイルで色々試してみました。
+
+
+以下のように逆コンパイルのテスト用ににジェネリクスを使用したJavaクラスと
+型をStringに設定したサブクラスをJavaとScalaで作成、
+そして今回の解決策とした型を確定させないScalaのサブクラスを
+定義しました。
+
+```java
+public class JavaBase<T> {
+  public void method1(T param) {
+  }
+  public void method2(T... params) {
+  }
+}
+```
+
+```java
+public class JavaSub extends JavaBase<String> {
+  public void method1(String param) {
+  }
+  public void method2(String... params) {
+  }
+}
+```
+
+```scala
+class ScalaSub extends JavaBase[String] {
+  override def method1(param: String) {
+  }
+  override def method2(params: String*) {
+  }
+}
+```
+
+```Scala
+class ScalaSub2[T] extends JavaBase[T] {
+  override def method1(param: T) {
+  }
+  override def method2(params: T*) {
+  }
+}
+```
+
+上記の各クラスを一旦classファイルにコンパイルし、逆コンパイルすると
+以下のようになります。
+
+```java
+public class JavaBase
+{
+    public void method1(Object obj)
+    {
+    }
+
+    public transient void method2(Object aobj[])
+    {
+    }
+}
+```
+
+```java
+public class JavaSub extends JavaBase
+{
+    public volatile void method1(Object obj)
+    {
+        method1((String)obj);
+    }
+
+    public void method1(String s)
+    {
+    }
+
+    public volatile void method2(Object aobj[])
+    {
+        method2((String[])aobj);
+    }
+
+    public transient void method2(String as[])
+    {
+    }
+}
+```
+
+```java
+public class ScalaSub extends JavaBase
+    implements ScalaObject
+{
+    public volatile void method1(Object param)
+    {
+        method1((String)param);
+    }
+
+    public void method1(String s)
+    {
+    }
+
+    public void method2(String params[])
+    {
+        method2(((Seq) (Predef$.MODULE$.wrapRefArray((Object[])params))));
+    }
+
+    public void method2(Seq seq)
+    {
+    }
+}
+```
+
+```java
+public class ScalaSub2 extends JavaBase
+    implements ScalaObject
+{
+    public void method1(Object obj)
+    {
+    }
+
+    public void method2(Object params[])
+    {
+        method2(((Seq) (Predef$.MODULE$.genericWrapArray(((Object) (params))))));
+    }
+
+    public void method2(Seq seq)
+    {
+    }
+}
+```
+ざっと見ていただければわかると思いますが、ジェネリクスで定義した型(T型)はObject型に
+置き換えられ、その中で確定させた型を引数とするメソッドを実行するようになっています。
+また可変長引数はObject型の配列となっています。
+ところが今回問題となっている型を確定させたScalaのサブクラス(ScalaSub)では
+Object型の配列を引数とするメソッドが生成されていません
+(かわりにStringの配列を引数とするメソッドとなっています)。
+
+ここからは推測となりますが、仮想マシンはジェネリクスな可変長引数のメソッドを
+実行する場合は、Object型の配列を引数とするメソッドを探して実行するはずのところ
+Scalaのサブクラスにはそのようなメソッドがないため、実行エラーとなっていると考えられます。
+可変長引数でない場合は、ScalaのサブクラスでもきちんとObject型引数メソッド内で
+String型引数メソッドを実行するようになっているため正常に実行出来ているようです。
+
+
+
+
+
+
+
+

実行環境が異なるので大丈夫かわかりませんが以下のような書き方で正常に動作しています。

Scala 2.9.1
sbt 0.11.3
android-plugin 0.6.1

import _root_.android.app.Activity
import _root_.android.os.Bundle
import _root_.android.os.AsyncTask
import _root_.android.util.Log

class MainActivity extends Activity with TypedActivity {
  override def onCreate(bundle: Bundle) {
    super.onCreate(bundle)
    setContentView(R.layout.main)

    findView(TR.textview).setText("hello, world!")

    val values:Seq[Int] = 1 to 10

    task.execute(values: _*)
  }
  private lazy val task = new TestTask

  override def onDestroy() {
    super.onDestroy()

    task.cancel(true)
  }

  abstract class MyAsyncTask[A, B, C] extends AsyncTask[A, B, C] {
    override protected def doInBackground(values: A*): C = {
      doInBackgroundImpl(values: _*)
    }
    protected def doInBackgroundImpl(values: A*): C
    override protected def onProgressUpdate(progress: B*) = {
      onProgressUpdateImpl(progress: _*)
    }
    protected def onProgressUpdateImpl(progress: B*)
  }

  class TestTask extends MyAsyncTask[Int, Int, Int] {
    override protected def onPreExecute() {
      Log.d("SampleProject", "onPreExecute()")
    }

    override protected def doInBackgroundImpl(values: Int*): Int = {
      Log.d("SampleProject", "doInBackground()")
      values.foreach {v =>
        Log.d("SampleProject", v.toString)
        publishProgress(v)
        Thread.sleep(1000)
      }
      values.foldLeft(0)(_ + _)
    }

    override protected def onProgressUpdateImpl(progress: Int*) {
      Log.d("SampleProject", "onProgressUpdate()")
      progress.foreach(v => Log.d("SampleProject", v.toString))
      findView(TR.textview).setText(progress.toString)
    }

    override protected def onPostExecute(result: Int) {
      Log.d("SampleProject", "onPostExecute()")
      Log.d("SampleProject", result.toString)
    }
  }
}

上記の書き方は色々試行錯誤していてたまたま動いたもので理由などはよくわからず、漠然と逆コンパイルすれば何かわかるかなと思っていたぐらいなのですが、ご質問いただいたので実際に逆コンパイルで色々試してみました。

以下のように逆コンパイルのテスト用ににジェネリクスを使用したJavaクラスと
型をStringに設定したサブクラスをJavaとScalaで作成、
そして今回の解決策とした型を確定させないScalaのサブクラスを
定義しました。

public class JavaBase<T> {
  public void method1(T param) {
  }
  public void method2(T... params) {
  }
}
public class JavaSub extends JavaBase<String> {
  public void method1(String param) {
  }
  public void method2(String... params) {
  }
}
class ScalaSub extends JavaBase[String] {
  override def method1(param: String) {
  }
  override def method2(params: String*) {
  }
}
class ScalaSub2[T] extends JavaBase[T] {
  override def method1(param: T) {
  }
  override def method2(params: T*) {
  }
}

上記の各クラスを一旦classファイルにコンパイルし、逆コンパイルすると
以下のようになります。

public class JavaBase
{
    public void method1(Object obj)
    {
    }

    public transient void method2(Object aobj[])
    {
    }
}
public class JavaSub extends JavaBase
{
    public volatile void method1(Object obj)
    {
        method1((String)obj);
    }

    public void method1(String s)
    {
    }

    public volatile void method2(Object aobj[])
    {
        method2((String[])aobj);
    }

    public transient void method2(String as[])
    {
    }
}
public class ScalaSub extends JavaBase
    implements ScalaObject
{
    public volatile void method1(Object param)
    {
        method1((String)param);
    }

    public void method1(String s)
    {
    }

    public void method2(String params[])
    {
        method2(((Seq) (Predef$.MODULE$.wrapRefArray((Object[])params))));
    }

    public void method2(Seq seq)
    {
    }
}
public class ScalaSub2 extends JavaBase
    implements ScalaObject
{
    public void method1(Object obj)
    {
    }

    public void method2(Object params[])
    {
        method2(((Seq) (Predef$.MODULE$.genericWrapArray(((Object) (params))))));
    }

    public void method2(Seq seq)
    {
    }
}

ざっと見ていただければわかると思いますが、ジェネリクスで定義した型(T型)はObject型に
置き換えられ、その中で確定させた型を引数とするメソッドを実行するようになっています。
また可変長引数はObject型の配列となっています。
ところが今回問題となっている型を確定させたScalaのサブクラス(ScalaSub)では
Object型の配列を引数とするメソッドが生成されていません
(かわりにStringの配列を引数とするメソッドとなっています)。

ここからは推測となりますが、仮想マシンはジェネリクスな可変長引数のメソッドを
実行する場合は、Object型の配列を引数とするメソッドを探して実行するはずのところ
Scalaのサブクラスにはそのようなメソッドがないため、実行エラーとなっていると考えられます。
可変長引数でない場合は、ScalaのサブクラスでもきちんとObject型引数メソッド内で
String型引数メソッドを実行するようになっているため正常に実行出来ているようです。

実行環境が異なるので大丈夫かわかりませんが以下のような書き方で正常に動作しています。

Scala 2.9.1
sbt 0.11.3
android-plugin 0.6.1

```scala
import _root_.android.app.Activity
import _root_.android.os.Bundle
import _root_.android.os.AsyncTask
import _root_.android.util.Log

class MainActivity extends Activity with TypedActivity {
  override def onCreate(bundle: Bundle) {
    super.onCreate(bundle)
    setContentView(R.layout.main)

    findView(TR.textview).setText("hello, world!")

    val values:Seq[Int] = 1 to 10

    task.execute(values: _*)
  }
  private lazy val task = new TestTask

  override def onDestroy() {
    super.onDestroy()

    task.cancel(true)
  }

  abstract class MyAsyncTask[A, B, C] extends AsyncTask[A, B, C] {
    override protected def doInBackground(values: A*): C = {
      doInBackgroundImpl(values: _*)
    }
    protected def doInBackgroundImpl(values: A*): C
    override protected def onProgressUpdate(progress: B*) = {
      onProgressUpdateImpl(progress: _*)
    }
    protected def onProgressUpdateImpl(progress: B*)
  }
  
  class TestTask extends MyAsyncTask[Int, Int, Int] {
    override protected def onPreExecute() {
      Log.d("SampleProject", "onPreExecute()")
    }

    override protected def doInBackgroundImpl(values: Int*): Int = {
      Log.d("SampleProject", "doInBackground()")
      values.foreach {v =>
        Log.d("SampleProject", v.toString)
        publishProgress(v)
        Thread.sleep(1000)
      }
      values.foldLeft(0)(_ + _)
    }

    override protected def onProgressUpdateImpl(progress: Int*) {
      Log.d("SampleProject", "onProgressUpdate()")
      progress.foreach(v => Log.d("SampleProject", v.toString))
      findView(TR.textview).setText(progress.toString)
    }

    override protected def onPostExecute(result: Int) {
      Log.d("SampleProject", "onPostExecute()")
      Log.d("SampleProject", result.toString)
    }
  }
}
```


上記の書き方は色々試行錯誤していてたまたま動いたもので理由などはよくわからず、漠然と逆コンパイルすれば何かわかるかなと思っていたぐらいなのですが、ご質問いただいたので実際に逆コンパイルで色々試してみました。


以下のように逆コンパイルのテスト用ににジェネリクスを使用したJavaクラスと
型をStringに設定したサブクラスをJavaとScalaで作成、
そして今回の解決策とした型を確定させないScalaのサブクラスを
定義しました。

```java
public class JavaBase<T> {
  public void method1(T param) {
  }
  public void method2(T... params) {
  }
}
```

```java
public class JavaSub extends JavaBase<String> {
  public void method1(String param) {
  }
  public void method2(String... params) {
  }
}
```

```scala
class ScalaSub extends JavaBase[String] {
  override def method1(param: String) {
  }
  override def method2(params: String*) {
  }
}
```

```Scala
class ScalaSub2[T] extends JavaBase[T] {
  override def method1(param: T) {
  }
  override def method2(params: T*) {
  }
}
```

上記の各クラスを一旦classファイルにコンパイルし、逆コンパイルすると
以下のようになります。

```java
public class JavaBase
{
    public void method1(Object obj)
    {
    }

    public transient void method2(Object aobj[])
    {
    }
}
```

```java
public class JavaSub extends JavaBase
{
    public volatile void method1(Object obj)
    {
        method1((String)obj);
    }

    public void method1(String s)
    {
    }

    public volatile void method2(Object aobj[])
    {
        method2((String[])aobj);
    }

    public transient void method2(String as[])
    {
    }
}
```

```java
public class ScalaSub extends JavaBase
    implements ScalaObject
{
    public volatile void method1(Object param)
    {
        method1((String)param);
    }

    public void method1(String s)
    {
    }

    public void method2(String params[])
    {
        method2(((Seq) (Predef$.MODULE$.wrapRefArray((Object[])params))));
    }

    public void method2(Seq seq)
    {
    }
}
```

```java
public class ScalaSub2 extends JavaBase
    implements ScalaObject
{
    public void method1(Object obj)
    {
    }

    public void method2(Object params[])
    {
        method2(((Seq) (Predef$.MODULE$.genericWrapArray(((Object) (params))))));
    }

    public void method2(Seq seq)
    {
    }
}
```
ざっと見ていただければわかると思いますが、ジェネリクスで定義した型(T型)はObject型に
置き換えられ、その中で確定させた型を引数とするメソッドを実行するようになっています。
また可変長引数はObject型の配列となっています。
ところが今回問題となっている型を確定させたScalaのサブクラス(ScalaSub)では
Object型の配列を引数とするメソッドが生成されていません
(かわりにStringの配列を引数とするメソッドとなっています)。

ここからは推測となりますが、仮想マシンはジェネリクスな可変長引数のメソッドを
実行する場合は、Object型の配列を引数とするメソッドを探して実行するはずのところ
Scalaのサブクラスにはそのようなメソッドがないため、実行エラーとなっていると考えられます。
可変長引数でない場合は、ScalaのサブクラスでもきちんとObject型引数メソッド内で
String型引数メソッドを実行するようになっているため正常に実行出来ているようです。

AsyncTaskはAndroid SDKのクラスなのでForAndroidは名前がおかしいんで修正しました。

20
     task.cancel(true)
   }
 
-  abstract class AsyncTaskForAndroid[A, B, C] extends AsyncTask[A, B, C] {
+  abstract class MyAsyncTask[A, B, C] extends AsyncTask[A, B, C] {
     override protected def doInBackground(values: A*): C = {
       doInBackgroundImpl(values: _*)
     }
     protected def onProgressUpdateImpl(progress: B*)
   }
   
-  class TestTask extends AsyncTaskForAndroid[Int, Int, Int] {
+  class TestTask extends MyAsyncTask[Int, Int, Int] {
     override protected def onPreExecute() {
       Log.d("SampleProject", "onPreExecute()")
     }

実行環境が異なるので大丈夫かわかりませんが以下のような書き方で正常に動作しています。

Scala 2.9.1
sbt 0.11.3
android-plugin 0.6.1

import _root_.android.app.Activity
import _root_.android.os.Bundle
import _root_.android.os.AsyncTask
import _root_.android.util.Log

class MainActivity extends Activity with TypedActivity {
  override def onCreate(bundle: Bundle) {
    super.onCreate(bundle)
    setContentView(R.layout.main)

    findView(TR.textview).setText("hello, world!")

    val values:Seq[Int] = 1 to 10

    task.execute(values: _*)
  }
  private lazy val task = new TestTask

  override def onDestroy() {
    super.onDestroy()

    task.cancel(true)
  }

  abstract class MyAsyncTask[A, B, C] extends AsyncTask[A, B, C] {
    override protected def doInBackground(values: A*): C = {
      doInBackgroundImpl(values: _*)
    }
    protected def doInBackgroundImpl(values: A*): C
    override protected def onProgressUpdate(progress: B*) = {
      onProgressUpdateImpl(progress: _*)
    }
    protected def onProgressUpdateImpl(progress: B*)
  }

  class TestTask extends MyAsyncTask[Int, Int, Int] {
    override protected def onPreExecute() {
      Log.d("SampleProject", "onPreExecute()")
    }

    override protected def doInBackgroundImpl(values: Int*): Int = {
      Log.d("SampleProject", "doInBackground()")
      values.foreach {v =>
        Log.d("SampleProject", v.toString)
        publishProgress(v)
        Thread.sleep(1000)
      }
      values.foldLeft(0)(_ + _)
    }

    override protected def onProgressUpdateImpl(progress: Int*) {
      Log.d("SampleProject", "onProgressUpdate()")
      progress.foreach(v => Log.d("SampleProject", v.toString))
      findView(TR.textview).setText(progress.toString)
    }

    override protected def onPostExecute(result: Int) {
      Log.d("SampleProject", "onPostExecute()")
      Log.d("SampleProject", result.toString)
    }
  }
}
実行環境が異なるので大丈夫かわかりませんが以下のような書き方で正常に動作しています。

Scala 2.9.1
sbt 0.11.3
android-plugin 0.6.1

```
import _root_.android.app.Activity
import _root_.android.os.Bundle
import _root_.android.os.AsyncTask
import _root_.android.util.Log

class MainActivity extends Activity with TypedActivity {
  override def onCreate(bundle: Bundle) {
    super.onCreate(bundle)
    setContentView(R.layout.main)

    findView(TR.textview).setText("hello, world!")

    val values:Seq[Int] = 1 to 10

    task.execute(values: _*)
  }
  private lazy val task = new TestTask

  override def onDestroy() {
    super.onDestroy()

    task.cancel(true)
  }

  abstract class MyAsyncTask[A, B, C] extends AsyncTask[A, B, C] {
    override protected def doInBackground(values: A*): C = {
      doInBackgroundImpl(values: _*)
    }
    protected def doInBackgroundImpl(values: A*): C
    override protected def onProgressUpdate(progress: B*) = {
      onProgressUpdateImpl(progress: _*)
    }
    protected def onProgressUpdateImpl(progress: B*)
  }
  
  class TestTask extends MyAsyncTask[Int, Int, Int] {
    override protected def onPreExecute() {
      Log.d("SampleProject", "onPreExecute()")
    }

    override protected def doInBackgroundImpl(values: Int*): Int = {
      Log.d("SampleProject", "doInBackground()")
      values.foreach {v =>
        Log.d("SampleProject", v.toString)
        publishProgress(v)
        Thread.sleep(1000)
      }
      values.foldLeft(0)(_ + _)
    }

    override protected def onProgressUpdateImpl(progress: Int*) {
      Log.d("SampleProject", "onProgressUpdate()")
      progress.foreach(v => Log.d("SampleProject", v.toString))
      findView(TR.textview).setText(progress.toString)
    }

    override protected def onPostExecute(result: Int) {
      Log.d("SampleProject", "onPostExecute()")
      Log.d("SampleProject", result.toString)
    }
  }
}
```

回答を投稿

実行環境が異なるので大丈夫かわかりませんが以下のような書き方で正常に動作しています。

Scala 2.9.1
sbt 0.11.3
android-plugin 0.6.1

import _root_.android.app.Activity
import _root_.android.os.Bundle
import _root_.android.os.AsyncTask
import _root_.android.util.Log

class MainActivity extends Activity with TypedActivity {
  override def onCreate(bundle: Bundle) {
    super.onCreate(bundle)
    setContentView(R.layout.main)

    findView(TR.textview).setText("hello, world!")

    val values:Seq[Int] = 1 to 10

    task.execute(values: _*)
  }
  private lazy val task = new TestTask

  override def onDestroy() {
    super.onDestroy()

    task.cancel(true)
  }

  abstract class AsyncTaskForAndroid[A, B, C] extends AsyncTask[A, B, C] {
    override protected def doInBackground(values: A*): C = {
      doInBackgroundImpl(values: _*)
    }
    protected def doInBackgroundImpl(values: A*): C
    override protected def onProgressUpdate(progress: B*) = {
      onProgressUpdateImpl(progress: _*)
    }
    protected def onProgressUpdateImpl(progress: B*)
  }

  class TestTask extends AsyncTaskForAndroid[Int, Int, Int] {
    override protected def onPreExecute() {
      Log.d("SampleProject", "onPreExecute()")
    }

    override protected def doInBackgroundImpl(values: Int*): Int = {
      Log.d("SampleProject", "doInBackground()")
      values.foreach {v =>
        Log.d("SampleProject", v.toString)
        publishProgress(v)
        Thread.sleep(1000)
      }
      values.foldLeft(0)(_ + _)
    }

    override protected def onProgressUpdateImpl(progress: Int*) {
      Log.d("SampleProject", "onProgressUpdate()")
      progress.foreach(v => Log.d("SampleProject", v.toString))
      findView(TR.textview).setText(progress.toString)
    }

    override protected def onPostExecute(result: Int) {
      Log.d("SampleProject", "onPostExecute()")
      Log.d("SampleProject", result.toString)
    }
  }
}
実行環境が異なるので大丈夫かわかりませんが以下のような書き方で正常に動作しています。

Scala 2.9.1
sbt 0.11.3
android-plugin 0.6.1

```
import _root_.android.app.Activity
import _root_.android.os.Bundle
import _root_.android.os.AsyncTask
import _root_.android.util.Log

class MainActivity extends Activity with TypedActivity {
  override def onCreate(bundle: Bundle) {
    super.onCreate(bundle)
    setContentView(R.layout.main)

    findView(TR.textview).setText("hello, world!")

    val values:Seq[Int] = 1 to 10

    task.execute(values: _*)
  }
  private lazy val task = new TestTask

  override def onDestroy() {
    super.onDestroy()

    task.cancel(true)
  }

  abstract class AsyncTaskForAndroid[A, B, C] extends AsyncTask[A, B, C] {
    override protected def doInBackground(values: A*): C = {
      doInBackgroundImpl(values: _*)
    }
    protected def doInBackgroundImpl(values: A*): C
    override protected def onProgressUpdate(progress: B*) = {
      onProgressUpdateImpl(progress: _*)
    }
    protected def onProgressUpdateImpl(progress: B*)
  }
  
  class TestTask extends AsyncTaskForAndroid[Int, Int, Int] {
    override protected def onPreExecute() {
      Log.d("SampleProject", "onPreExecute()")
    }

    override protected def doInBackgroundImpl(values: Int*): Int = {
      Log.d("SampleProject", "doInBackground()")
      values.foreach {v =>
        Log.d("SampleProject", v.toString)
        publishProgress(v)
        Thread.sleep(1000)
      }
      values.foldLeft(0)(_ + _)
    }

    override protected def onProgressUpdateImpl(progress: Int*) {
      Log.d("SampleProject", "onProgressUpdate()")
      progress.foreach(v => Log.d("SampleProject", v.toString))
      findView(TR.textview).setText(progress.toString)
    }

    override protected def onPostExecute(result: Int) {
      Log.d("SampleProject", "onPostExecute()")
      Log.d("SampleProject", result.toString)
    }
  }
}
```