updates docs for v1

Author: shanerbaner82

resources/views/docs/mobile/1/digging-deeper/push-notifications.md

@@ -0,0 +1,96 @@
+---
+title: Push Notifications
+order: 400
+---
+
+
+## Overview
+
+NativePHP for Mobile uses [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging) to send push notifications to your users.
+
+## Setting up your app
+
+Once you create a Firebase account and create a project you will be offered to download a `google-services.json` file.
+
+This file contains the configuration for your app and is used by the Firebase SDK to retrieve tokens for each device using your app.
+
+Simply drag this file into the root of your Laravel project, enable `push_notifications` in the [config](/docs/mobile/1/getting-started/configuration) it will be used automatically.
+
+You will see more instructions on how to configure your app in the Firebase documentation, you can ignore all of those, NativePHP handles all of that for you.
+
+## Receiving Push Tokens
+
+To receive push notifications, you must register a listener for the event. For example,
+take a look at how easy it is to listen for a `TokenGenerated` event in Livewire:
+
+```php
+use Livewire\Attributes\On;
+use Livewire\Component;
+use Native\Mobile\Facades\System;
+use Native\Mobile\Events\PushNotification\TokenGenerated;
+
+class PushNotifications extends Component
+{
+    public function render()
+    {
+        return view('livewire.system.push-notifications');
+    }
+
+    #[On('native:' . TokenGenerated::class)]
+    public function handlePushNotifications(string $token)
+    {
+        // Do something with the token...
+    }
+}
+```
+
+Because of the nature of mobile applications you need an api server to handle these tokens. You can use Laravel's built-in `Http` facade to 
+`POST` the token to your server, on the server side you need to associate the token with the "user" that owns the device.
+
+We **strongly** recommend using [Sanctum](https://laravel.com/docs/12.x/sanctum#main-content) to handle this for you.
+
+## The flow
+
+Your app authenticates users against your own api server, when users create an account or login the server validates and authenticates the user and passes back a Sanctum token.
+
+The token is stored in your apps `session` and is used on subsequent requests to the api server.
+
+When a push notification is received, the token is sent to your api server and the server stores it for the user who sent it.
+
+> Optionally, you can have a `HasMany` relationship between your users and devices, 
+> this allows you to associate a device with a user and then use the device's token 
+> to send push notifications to that users devices.
+
+## Sending Push Notifications
+
+Once you have the token, you may use it from your server-based applications to trigger Push Notifications directly to
+your user's device. We use a package like [google/apiclient](https://github.com/googleapis/google-api-php-client) to send the notifications.
+
+This is the exact code used by the NativePHP Kitchen Sink App (available soon on all app stores and GitHub):
+
+```php
+Route::group(['middleware' => 'auth:sanctum'], function () {
+    Route::post('send-push-notification', PushNotificationController::class)->name('send-push-notification');
+});
+```
+
+```php
+namespace App\Http\Controllers;
+
+use App\Jobs\SendPushNotification;
+use Illuminate\Http\Request;
+
+class PushNotificationController extends Controller
+{
+    public function __invoke(Request $request)
+    {
+        $token = $request->get('token');
+
+        $request->user()->update([
+            'push_token' => $token
+        ]);
+
+        SendPushNotification::dispatch($token)->delay(now()->addMinutes(1));
+    }
+}
+```

resources/views/docs/mobile/1/getting-started/debugging.md

@@ -6,13 +6,7 @@ order: 300
 
 ## The `nativephp` Directory
 
-After running:
-
-```bash
-php artisan native:install
-```
-
-you’ll see a new `nativephp` directory at the root of your Laravel project as well as a nativephp.php config file in your config folder in the Laravel root.
+After running: `php artisan native:install` you’ll see a new `nativephp` directory at the root of your Laravel project as well as a `nativephp.php` config file in your config folder in the Laravel root.
 
 This folder contains all the native project files that NativePHP generates for you.
 

resources/views/docs/mobile/1/getting-started/development.md

@@ -23,16 +23,18 @@ order: 100
 
 #### For macOS
 ```shell
-export JAVA_HOME=$(/usr/libexec/java_home -v 17)
+export JAVA_HOME=$(/usr/libexec/java_home -v 17) // This isn't required if JAVA_HOME is already set in the Windows Env Variables
 export ANDROID_SDK_ROOT=$HOME/Library/Android/sdk
 export PATH=$PATH:$JAVA_HOME/bin:$ANDROID_HOME/emulator:$ANDROID_HOME/tools:$ANDROID_HOME/tools/bin:$ANDROID_HOME/platform-tools
 ```
 
 #### For Windows
 ```shell
-set JAVA_HOME=C:\Program Files\Microsoft\jdk-17.0.8.7-hotspot
 set ANDROID_SDK_ROOT=C:\Users\yourname\AppData\Local\Android\Sdk
 set PATH=%PATH%;%JAVA_HOME%\bin;%ANDROID_SDK_ROOT%\platform-tools
+
+# This isn't required if JAVA_HOME is already set in the Windows Env Variables
+set JAVA_HOME=C:\Program Files\Microsoft\jdk-17.0.8.7-hotspot
 ```
 
 > **Note** You cannot build iOS apps on Windows or Linux
@@ -47,13 +49,14 @@ NativePHP for mobile is built to work with Laravel. You can install it into an e
 [start a new one](https://laravel.com/docs/installation). The most painless way to get PHP and Node up and running on your system is with
 [Laravel Herd](https://herd.laravel.com). It's fast and free!
 
-## Private package
+
+## Install NativePHP for mobile
 
 To make NativePHP for mobile a reality has taken a lot of work and will continue to require even more. For this reason,
 it's not open source, and you are not free to distribute or modify its source code.
 
 Before you begin, you will need to purchase a license.
-Licenses can be obtained via [Anystack](https://checkout.anystack.sh/nativephp-ios).
+Licenses can be obtained via [Anystack](https://checkout.anystack.sh/nativephp).
 
 Once you have your license, you will need to add the following to your `composer.json`:
 
@@ -66,8 +69,7 @@ Once you have your license, you will need to add the following to your `composer
 ],
 ```
 
-## Install NativePHP for mobile
-
+Then run:
 ```shell
 composer require nativephp/mobile
 ```
@@ -77,7 +79,7 @@ If this is the first time you're installing the package, you will be prompted to
 This package contains all the libraries, classes, commands, and interfaces that your application will need to work with
 iOS and Android.
 
-Before running the `install` command it is important to set the following variables in your `.env`:
+**Before** running the `install` command it is important to set the following variables in your `.env`:
 
 ```shell
 NATIVEPHP_APP_ID=com.nativephp.yourapp

resources/views/docs/mobile/1/getting-started/env-files.md

@@ -22,7 +22,7 @@ Presently, NativePHP for mobile offers the following "native" functionality:
 - Deep Links
 - NFC
 
-We're working on adding more and more features, including:
+We're working on adding more and more features, including (in no particular order):
  - Secure Storage
  - Microphone access
  - Location

resources/views/docs/mobile/1/getting-started/installation.md

@@ -10,7 +10,7 @@ NativePHP for Mobile supports both **deep linking** and **web-based linking** in
 There are two types of link integrations you can configure:
 
 - **Deep Links** (myapp://some/path)
-- **Universal Links (iOS)** and **App Links (Android)** (https://yourdomain.com/some/path)
+- **Universal Links (iOS)** and **App Links (Android)** (https://example.net/some/path)
 
 Each method has its use case, and NativePHP allows you to configure and handle both easily.
 
@@ -49,7 +49,7 @@ Universal Links and App Links allow real HTTPS URLs to open your app instead of
 
 For example:
 ```dotenv
-https://bifrost.tech/property/456
+https://example.net/property/456
 ```
 
 When a user taps this link:
@@ -72,22 +72,22 @@ NativePHP for Mobile handles all of this for you.
 
 To enable Universal Links and App Links, you must define:
 
-- **Host**: The domain name (e.g., bifrost-tech.com)
+- **Host**: The domain name (e.g., example.net)
 
 These are configured in your .env:
 
 ```dotenv
-NATIVEPHP_DEEPLINK_HOST=bifrost-tech.com
+NATIVEPHP_DEEPLINK_HOST=example.net
 ```
 
 ## Handling Universal/App Links
 
 Once you've configured your deep link settings, you can handle the link in your app.
 
-Simply setup a route in your web.php file and the deeplink will redirect to your route.
+Simply set up a route in your web.php file and the deeplink will redirect to your route.
 
 ```dotenv
-https://bifrost-tech.com/profile/123
+https://example.net/profile/123
 ```
 
 ```php

resources/views/docs/mobile/1/getting-started/status.md renamed to resources/views/docs/mobile/1/getting-started/roadmap.md

@@ -10,7 +10,7 @@ NativePHP allows you to trigger many native dialogs.
 Dialogs are created using the `Dialog` facade.
 
 ```php
-use Native\Ios\Facades\Dialog;
+use Native\Mobile\Facades\Dialog;
 ```
 
 ### The Share Dialog

resources/views/docs/mobile/1/the-basics/app-lifecycle.md

@@ -0,0 +1,70 @@
+---
+title: Native Functions
+order: 1
+---
+
+Nearly any basic Laravel app will work as a mobile app with NativePHP for mobile. However, what makes NativePHP
+unique is that it allows you to call native functions from your PHP code.
+
+These functions are called from your PHP code using one of an ever-growing list of facades.
+
+Currently, there are two facades available:
+
+- `Native\Mobile\Facades\System`
+- `Native\Mobile\Facades\Dialog`
+
+## System
+
+The `System` facade is used to call native functions that access system resources.
+
+For example, you may use the `System::camera()` method to request access to the device's camera.
+
+
+## Synchronous vs. Asynchronous Methods
+
+It is important to understand the difference between synchronous and asynchronous methods. Some methods
+like `flashlight` and `vibrate` are synchronous, meaning that they will block the current thread until the
+operation is complete. 
+
+Other methods like `camera` and `biometric` are asynchronous, meaning that they
+will return immediately and the operation will be performed in the background. When the operation is
+complete, the method will `broadcast an event` to your frontend via an injected javascript event as well 
+as a traditional [Laravel Event](https://laravel.com/docs/12.x/events#main-content) that you can listen for within your app.
+
+In order to receive these events, you must register a listener for the event. For example,
+take a look at how easy it is to listen for a `PhotoTaken` event in Livewire:
+
+```php
+use Livewire\Attributes\On;
+use Livewire\Component;
+use Native\Mobile\Facades\System;
+use Native\Mobile\Events\Camera\PhotoTaken;
+
+class Camera extends Component
+{
+    public string $photoDataUrl = '';
+
+    public function camera()
+    {
+       System::camera();
+    }
+
+    #[On('native:' . PhotoTaken::class)]
+    public function handleCamera($path)
+    {
+        $data   = base64_encode(file_get_contents($path));
+        $mime   = mime_content_type($path);
+
+        $this->photoDataUrl = "data:$mime;base64,$data";
+    }
+
+    public function render()
+    {
+        return view('livewire.system.camera');
+    }
+}
+```
+
+All Livewire/front end events are prefixed with `native:` to avoid collisions with other events. 
+In the following pages we will highlight the available native functions, whether they are asynchronous or not
+and which events they fire.