Smali File Structure

Please consider this code:

.class public Lde/fgerbig/spacepeng/components/Player;
.super Lcom/artemis/Component;
.source "Player.java"


# annotations
.annotation build Lcom/artemis/annotations/PooledWeaver;
.end annotation

.annotation system Ldalvik/annotation/MemberClasses;
    value = {
        Lde/fgerbig/spacepeng/components/Player$State;
    }
.end annotation


# static fields
.field public static final DEFAULT_LIVES:I = 0x5

.field public static final SPRITE_NAME:Ljava/lang/String; = "player"

.field public static final SPRITE_NAME_SHIELD:Ljava/lang/String; = "playershield"


# instance fields
.field public lives:I

.field public score:I

.field private state:Lde/fgerbig/spacepeng/components/Player$State;


# direct methods
.method public constructor <init>()V
    .locals 1

    .prologue
    .line 24
    invoke-direct {p0}, Lcom/artemis/Component;-><init>()V

    .line 37
    sget-object v0, Lde/fgerbig/spacepeng/components/Player$State;->ALIVE:Lde/fgerbig/spacepeng/components/Player$State;

    iput-object v0, p0, Lde/fgerbig/spacepeng/components/Player;->state:Lde/fgerbig/spacepeng/components/Player$State;

    .line 39
    const/4 v0, 0x5

    iput v0, p0, Lde/fgerbig/spacepeng/components/Player;->lives:I

    return-void
.end method


# virtual methods
.method public isState(Lde/fgerbig/spacepeng/components/Player$State;)Z
    .locals 1
    .param p1, "state"    # Lde/fgerbig/spacepeng/components/Player$State;

    .prologue
    .line 47
    iget-object v0, p0, Lde/fgerbig/spacepeng/components/Player;->state:Lde/fgerbig/spacepeng/components/Player$State;

    invoke-virtual {v0, p1}, Lde/fgerbig/spacepeng/components/Player$State;->equals(Ljava/lang/Object;)Z

    move-result v0

    return v0
.end method

.method public setState(Lde/fgerbig/spacepeng/components/Player$State;)V
    .locals 0
    .param p1, "state"    # Lde/fgerbig/spacepeng/components/Player$State;

    .prologue
    .line 43
    iput-object p1, p0, Lde/fgerbig/spacepeng/components/Player;->state:Lde/fgerbig/spacepeng/components/Player$State;

    .line 44
    return-void
.end method

Sure! Here's a breakdown of the Smali file structure for the given code:

.class

directive: This declares the name and access level of the class. In this case, the class is named

Player

and is declared as

public

.super

directive: It extends the

com.artemis.Component

class.

.source

directive: This specifies the name of the Java source file that the Smali code was generated from.

Annotations: The

.annotation

directives define two annotations:

@com.artemis.annotations.PooledWeaver

: This annotation is used to indicate that instances of the class should be pooled by the Artemis Entity System framework.

@dalvik.annotation.MemberClasses

: This annotation is used to specify the inner classes of the

Player

class. In this case, there is only one inner class,

Player$State

Note: In here

State

isn’t a class, rather it’s a

enum

Static fields:

In object-oriented programming, static fields are class-level variables that are shared by all instances of a class. Unlike instance fields, which have a separate value for each object of the class, static fields have the same value for all objects of the class.

The

.field

directives define three static fields:

DEFAULT_LIVES

: This field is an integer constant with a value of

0x5

SPRITE_NAME

: This field is a string constant with a value of

"player"

SPRITE_NAME_SHIELD

: This field is a string constant with a value of

"playershield"

Instance fields:

In object-oriented programming, instance fields are non-static variables that are declared at the class level and are associated with each instance of the class. Each object of the class has its own copy of the instance fields.

The

.field

directives define three instance fields:

lives

: This field is an integer and represents the number of lives the player has.

score

: This field is an integer and represents the player's score.

state

: This field is an instance of the

Player$State

inner class and represents the current state of the player.

Direct methods:

In the context of Android app development, direct methods refer to methods that are called using the

invoke-direct

instruction in Dalvik bytecode. Direct methods are typically used for constructors, private methods and static methods. In Java and other object-oriented languages, constructors are special methods that are used to initialize the state of an object when it is created. Constructors are called using the

new

operator and cannot be called directly by name. In Dalvik bytecode, constructors are implemented as direct methods, which are called using the

invoke-direct

instruction.

The

.method

directive defines a constructor method:

<init>

: This is the constructor method, with a signature of

()V

. It calls the constructor of the

com.artemis.Component

class, sets the initial state to

ALIVE

, and sets the default number of lives to

Virtual methods:

In object-oriented programming, virtual methods are methods that are

public

protected

which declared in a class and can be overridden in a subclass(final classes are virtual method too, but can’t overwritten). When a virtual method is called on an object, the runtime system determines which implementation of the method to use based on the actual type of the object, rather than the declared type of the reference. In Java and other object-oriented languages, all non-static methods are virtual by default, unless they are declared as

final

private

, which prevents them from being overridden. This allows subclasses to provide their own implementation of the method, which can be customized to suit their specific needs

The

.method

directives define two virtual methods:

isState

: This method takes a

Player$State

object as a parameter and returns a Boolean indicating whether the player's current state matches the specified state.

setState

: This method takes a

Player$State

object as a parameter and sets the player's state to the specified value.

Overall, the

Smali

file structure closely mirrors the structure of the original Java class, with some additional directives and annotations that are specific to the Dalvik bytecode format.

Task

Provide Java code of this smali code:

# virtual methods
.method public addPower(III)D
    .locals 5
    .param p1, "a"    # I
    .param p2, "b"    # I
    .param p3, "factor"    # I

    .line 13
    const/4 v0, 0x0

    .line 15
    .local v0, "sum":I
    const-wide v1, 0x4002666666666666L    # 2.3

    .line 17
    .local v1, "bias":D
    add-int v3, p1, p2

    mul-int v3, v3, p3

    .line 19
    .end local v0    # "sum":I
    .local v3, "sum":I
    add-int/lit8 v3, v3, -0x1

    .line 21
    div-int p1, v3, p2

    .line 23
    xor-int v0, v3, p1

    .line 25
    .end local v3    # "sum":I
    .restart local v0    # "sum":I
    int-to-double v3, v0

    return-wide v3
.end method

Solution

Tasks

reverse engineer

Spacepeng

app and change player health to 999