# eDO Setup Guide

## How to build your project with eDO

If you are using [Bazel](https://bazel.build/), normally, you will have at
least two BUILD files

<!--zippy-->

BUILD for the `Host` and `YourClass`

```build

# The Host binary that starts the EDOHostService.
objc_library(
    name = "Host",
    srcs = [
      "Host.m",
    ],
    deps = [
      ":YourClass",  # Your actual class implementation
      "//third_party/objective_c/eDistantObject",
    ]
)

# YourClass library
objc_library(
    name = "YourClass",
    srcs = ["YourClass.m"],
    deps = [":Headers"],
)

# Expose YourClass headers as a separate target so the client can use it
# without linking the binary.
objc_library(
    name = "Headers",
    hdrs = ["YourClass.h"],
    # If there is any deps, make sure it will not introduce any binary unit that
    # is going to link with the client.
)

```

<!--endzippy-->

<!--zippy-->

BUILD for the `Client` to use `YourClass`

```build
# The client that uses YourClass from a different process.
objc_library(
    name = "Client",
    srcs = ["Client.m"],
    deps = [
        ":Headers",
        "//third_party/objective_c/eDistantObject",
    ]
)

```

<!--endzippy-->

This is an example using [Bazel](https://bazel.build/). For other build tools,
the rule is to import headers and implementations in one process, while import
only headers in the other process who makes remote invocations using methods
defined in the headers.

## Where to write code

When you need to write code that will jump between two processes, it can be
confusing to say in which process the actual implementation and its stub/proxy
call should be.

For example, you already have an API in the host process to get the element from
an internal array, and you need another API to do some complicated logic to
process the number in client process.
In this case, since only the host process has access to the internal data, we
should keep the old API in host process and let the client process hold a distant
object of it.

```objectivec
// In the host process

@implementation HostDistantObject {
  NSArray<NSNumber *>* _myArray;
}

- (NSNumber *)getNumber:(NSInteger *)index {
  return [_myArray objectAtIndex:index];
}

@end
```

```objectivec
// In the client process
- (void)processFirstNumber {
    NSNumber *firstNumber = [HostDistantObject.sharedInstance getNumber:0];
    // Do some complicated logic with the remote object firstNumber...
}
```

In the example above, the client process holds a remote instance of
`HostDistantObject`. And the API `getNumber:` actually runs in host process.
Then the client process receives another remote instance of `NSNumber` and
can do whatever logic on it.