As it turned out, WiFi is not turned on by default on the phone, and to switch it on there are several tricky steps to do. At first, you’d better to have some Ubuntu Linux (in my case it was version 9.04). Probably it’s possible to use other systems, but that was my case. Secondly it’s necessary to download and unzip Android SDK to use management tools a little bit further. To be able to connect the phone via USB cable to PC one should create the file /etc/udev/rules.d/50-android.rules

$ sudo gedit /etc/udev/rules.d/50-android.rules

and put the following line to it:

SUBSYSTEM=="usb", SYSFS{idVendor}=="0bb4", MODE="0666"

Then we change permissions for this file as follows:

sudo chmod a+rx /etc/udev/rules.d/50-android.rules

After extracting Android SDK archive to some directory we go to the `tools’ folder and run Android debugger daemon:

./adb devices

to obtain a prompt like this

List of devices attached
HT847GZ20615	device

In my case it didn’t work from scratch (my device didn’t appear in the list), presumably, because of some problems with Ububntu 9.04, so, the solution was quite simple: to copy configuration file (not to move!). Connecting USB cable of the phone into a different port also may help.

sudo cp /etc/udev/rules.d/50-android.rules /etc/udev/rules.d/51-android.rules

After device is recognized, run remote shell from the same `tools’ folder. Being connected, switch to the superuser and run Android Settings application:

$ ./adb shell
$ su
# am start -a android.intent.action.MAIN -n com.android.settings/.Settings
#

Here we are! Now you can see the screen of Settings application on your phone. It’s a deal of a couple of seconds to switch on WiFi, but in my case it wasn’t an end. the problem was that only one available wireless network demanded for web-login, so I had to login to it somehow.
Quick introspection of /data/app folder of the phone filesystem let me see a Browser application. That’s possible what I need. To run a browser remotely on should run the following command:

# am start -a android.intent.action.MAIN -n com.android.browser/.BrowserActivity

After being logged into our wireless network, I’ve restarted my phone and now I was able to sign in.

UPD. Tried the same on Mac OS X. It’s supposed to work out of the box without any pre-configuration. Just download SDK, plug USB and have fun!

All comments and suggestions are highly appreciated.

At the same time we have such issue for Scala also, but almost all of auxiliary classes (like FunctionN, Iterable etc) in Scala may be used directly, so it would be naive to exclude them form debug process. Say, I’ve implemented my own Function2X inherited form scala.Function2 and I actually want to debug it during execution.

That’s why for next release of Scala plugin for IntelliJ we added one checkbox to debugger settings for Scala.

Making this magic box marked, you exclude all classes which qualified name starts with “scala.runtime.*” from debug process. I. e. debugger will not step automatically into them. I suppose, it’s not the full set of classes which would be right to exclude, so it’s discussable questions and any suggestions are appreciated.

Just remind that you may also use customizable class filter for such, which is available from Java debugger settings.

It seems to be a better solution for Scala, cause unlike Groovy it has no such amount of auxiliary classes. But who knows…

def foo = {
  case P1 => ...
  //...
  case Pn => ...
}

defines partially applied function foo() which does something on inputs, which match either patterns P1,…,Pn and throws MatchError otherwise. The signature of trait PartialFunction is

package scala

trait PartialFunction[-A, +B] extends AnyRef with (A => B) {
  def isDefinedAt(x: A): Boolean
  def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1, B1]) : PartialFunction[A1, B1]
  override def andThen[C](k: B => C) : PartialFunction[A, C]
}

As it might be seen, PartialFunction extends trait Function1[-A, +B], which is represented here by notation (A=>B). The principal method is isDefinedAt(). It checks, wheter tihs partial function matches its argument, or not.

So, we’re done with piece of theory.

The problem I faced today relates to analysis of some segment of code written in Scala. Say, we have  a declaration of function:

@throws(classOf[IOException]) def readFile(f: File): Unit

During the compilation to bytecode Scala compiler will treat annotation @throws to produce signatures with specified exceptions, which would be visible in their order to Java compiler if we decide, for instance, override method readFile(). To pick this kind of information by method signature in Scala from appropriate CST we have to climb into subtree, corresponding @throws annotation invocation and check all conditions: this annotation is resolved to correct class, its argument exists etc. That’s why the first implementation of these checks looked like that:

   private def extractExceptionType(a: ScAnnotation) = {
    val constr = a.annotationExpr.constr
    constr.typeElement.reference.map(_.bind) match {
      case Some(Some(res: ScalaResolveResult)) => res.getElement match {
        case c: PsiClass if c.getQualifiedName == "scala.throws" => constr.args match {
          case args: ScArgumentExprList if args != null => args.exprs match {
            case Seq(gc@(_: ScGenericCall)) => gc.referencedExpr match {
              case ref: ScReferenceExpression => ref.bind.map(_.getElement) match {
                case Some(m: PsiMethod) if m.getName == "classOf" => gc.typeArgs.typeArgs match {
                  case Seq(s: ScSimpleTypeElement) => s.reference.map(_.bind) match {
                    case Some(Some(res1: ScalaResolveResult)) => res1.getElement match {
                      case p: PsiClass => p.getClassType
                      case _ => null
                    }
                    case _ => null
                  }
                  case _ => null
                }
                case _ => null
              }
              case _ => null
            }
            case _ => null
          }
          case _ => null
        }
        case _ => null
      }
      case None => null
    }
  }

Looks ugly, doesn’t it? In my defence may say, that wrighting all this checks I didn’t thinks about christmas tree of nested “matches” which I got as result.

The first attempt to make this code a bit more good-looking was to eliminate all “secondary” branches of match statements at a stroke, wrapping them to one exception handling:

  private def extractExceptionType(a: ScAnnotation) = {   
    val constr = a.annotationExpr.constr
    try {
      constr.typeElement.reference.map(_.bind) match {
        case Some(Some(res: ScalaResolveResult)) => res.getElement match {
          case c: PsiClass if c.getQualifiedName == "scala.throws" => constr.args match {
            case args: ScArgumentExprList if args != null => args.exprs match {
              case Seq(gc@(_: ScGenericCall)) => gc.referencedExpr match {
                case ref: ScReferenceExpression => ref.bind.map(_.getElement) match {
                  case Some(m: PsiMethod) if m.getName == "classOf" => gc.typeArgs.typeArgs match {
                    case Seq(s: ScSimpleTypeElement) => s.reference.map(_.bind) match {
                      case Some(Some(res1: ScalaResolveResult)) => res1.getElement match {
                        case p: PsiClass => p.getClassType
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
    catch {
      case e: MatchError => null
    }
  }

Looks a bit less ugly, but I still cannot say that this wedge-like code makes me happy. At this moment you can notice, that almost all checks of our nested sequence are performed by single pattern:

case P(x1,...,x_n) => fun(x1,... x_n) match {...}

In other words, every pattern matching binds new set of variables, evaluates some expression with them and passes its result to next check. So, why don’t us adjust it in continuation-passing style via list of partially applied functions? Firstly, let’s define an auxiliary function to perform our sequence of applications:

def foldFuns(initial: Any)(fail: Any)(l: List[PartialFunction[Any, _]]): Any = l match {
    case h :: t => if (h.isDefinedAt(initial)) foldFuns(h(initial))(fail)(t) else fail
    case Nil => initial
  }

In other words, our high-order function foldFuns() takes initial element, result which will be returned in a case of failure and a list of partially applied funtions. It performs a composition of given list of functions with the one difference that in a case of unmatching argument fail result will be returned.

Finally, we rewrite our checks using foldFuns() function:

  private def extractExceptionType(a: ScAnnotation) = {
    val constr = a.annotationExpr.constr
    val result = foldFuns(constr.typeElement.reference.map(_.bind))(null)(List(
      {case Some(Some(res: ScalaResolveResult)) => res.getElement},
      {case c: PsiClass if c.getQualifiedName == "scala.throws" => constr.args},
      {case args: ScArgumentExprList if args != null => args.exprs},
      {case Seq(gc@(_: ScGenericCall)) => (gc.referencedExpr, gc.typeArgs.typeArgs)},
      {case (ref: ScReferenceExpression, ta) => (ref.bind.map(_.getElement), ta)},
      {case (Some(m: PsiMethod), ta) if m.getName == "classOf" => ta},
      {case Seq(s: ScSimpleTypeElement) => s.reference.map(_.bind)},
      {case Some(Some(res1: ScalaResolveResult)) => res1.getElement},
      {case p: PsiClass => p.getClassType}
      ))

    result match {
      case p: PsiClassType => p
      case _ => null
    }
  }

This code is still no perfect. Mainly by the reason, that we still have to “cast” our result at the end to “correct” type. The most attentice ones could notice, that we had to jam parameter “ta” (derived initially from TypeArguments) through several calls, cause with such implementation every function has its own context.

As for explicit typecast at the end, we could avoid it by introducing result’s type as generic type parameter of foldFuns() function, but in such case we also shoud separate last member of function list as a standalone parameter. Or, may be, someone could propose more elegant solution?

Subject

It’s right question to ask, why do the world need for one more blog?

Honestly speaking, I don’t know, but as it seems to me, I have some minds which I would like to share with other. The most part of them will be of technical direction and related to my investigations in computer science, software engineering and digital signal processing.

So, see you soon!