Update mobile documentation with enhanced deep links, push notifications, and database seeding

- Enhanced deep links documentation with comprehensive platform-specific setup, domain verification, and NFC integration
- Expanded push notifications docs with FCM implementation, platform-specific configurations, and data payload handling
- Added database seeding section explaining how to use migrations for initial data setup
- Updated various documentation files with improved clarity and additional configuration examples
- Fixed broken links and improved navigation structure

Author: shanerbaner82

resources/views/docs/mobile/1/concepts/databases.md

@@ -27,6 +27,58 @@ upon foreign key constraints, [you need to enable SQLite support for them](https
 **It's important to test your migrations on prod builds before releasing updates!** You don't want to accidentally
 delete your user's data when they update your app.
 
+## Seeding Data with Migrations
+
+Migrations are the perfect mechanism for seeding data in mobile applications. They provide the natural behavior you want for data seeding:
+
+- **Run once**: Each migration runs exactly once per device
+- **Tracked**: Laravel tracks which migrations have been executed
+- **Versioned**: New app versions can include new data seeding migrations
+- **Reversible**: You can create migrations to remove or update seed data
+
+### Creating Seed Migrations
+
+Create dedicated migrations for seeding data:
+
+```bash
+php artisan make:migration seed_default_categories
+php artisan make:migration seed_app_settings
+php artisan make:migration seed_initial_user_data
+```
+
+### Example: Seeding Default Categories
+
+```php
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\DB;
+
+return new class extends Migration
+{
+    public function up()
+    {
+        DB::table('categories')->insert([
+            ['name' => 'Work', 'color' => '#3B82F6'],
+            ['name' => 'Personal', 'color' => '#10B981'],
+        ]);
+    }
+
+    public function down()
+    {
+        // Rollback/fresh migrations never run
+    }
+};
+```
+
+### Best Practices for Seed Migrations
+
+1. **Use specific timestamps**: Name migrations with dates to ensure proper ordering
+2. **Check before inserting**: Prevent duplicate data with updateOrCreate() or firstOrCreate()
+3. **Handle conflicts gracefully**: Check if data already exists before seeding
+4. **Use realistic data**: Seed with data that matches your production environment
+5. **Test thoroughly**: Verify seed migrations work on fresh installs and updates
+
+This approach ensures your mobile app has the initial data it needs while maintaining consistency across different app versions and user devices.
+
 ## Things to note
 
 - As your app is installed on a separate device, you do not have remote access to the database.

resources/views/docs/mobile/1/concepts/deep-links.md

@@ -12,7 +12,7 @@ There are two types of link integrations you can configure:
 - **Deep Links** (myapp://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.
+Each method has its use case, and NativePHP handles all the platform-specific configuration automatically when you provide the proper environment variables.
 
 ---
 
@@ -26,7 +26,6 @@ For example:
 myapp://profile/123
 ```
 
-
 When a user taps a deep link, the mobile operating system detects the custom scheme and opens your app directly.
 
 ### Configuration
@@ -43,6 +42,12 @@ NATIVEPHP_DEEPLINK_SCHEME=myapp
 NATIVEPHP_DEEPLINK_HOST=open
 ```
 
+### Platform Behavior
+
+- **iOS**: Deep links work immediately after installation
+- **Android**: Deep links work immediately after installation
+- **Both**: Apps will open directly when deep links are tapped
+
 ## Universal Links (iOS) and App Links (Android)
 
 Universal Links and App Links allow real HTTPS URLs to open your app instead of a web browser, if the app is installed.
@@ -52,21 +57,25 @@ For example:
 https://example.net/property/456
 ```
 
+### User Experience
+
 When a user taps this link:
 
- - If your app is installed, it opens directly into the app.
- - If not, it opens normally in the browser.
+- **If your app is installed**: It opens directly into the app
+- **If not installed**: It opens normally in the browser
+- **Seamless fallback**: No broken experience for users without the app
 
 This provides a seamless user experience without needing a custom scheme.
 
 ### How It Works
-1. You must prove to iOS and Android that you own the domain by hosting a special file:
- - .well-known/apple-app-site-association (for iOS)
- - .well-known/assetlinks.json (for Android)
-2. The mobile OS reads these files to verify the link association.
-3. Once verified, tapping a real URL will open your app instead of Safari or Chrome.
 
-NativePHP for Mobile handles all of this for you.
+1. You must prove to iOS and Android that you own the domain by hosting special files:
+   - `.well-known/apple-app-site-association` (for iOS)
+   - `.well-known/assetlinks.json` (for Android)
+2. The mobile OS reads these files to verify the link association
+3. Once verified, tapping a real URL will open your app instead of Safari or Chrome
+
+**NativePHP handles all the technical setup automatically** - you just need to host the verification files and configure your domain.
 
 ### Configuration
 
@@ -80,6 +89,87 @@ These are configured in your .env:
 NATIVEPHP_DEEPLINK_HOST=example.net
 ```
 
+#### Complete Configuration Example
+
+```dotenv
+# For both deep links and universal/app links
+NATIVEPHP_DEEPLINK_SCHEME=myapp
+NATIVEPHP_DEEPLINK_HOST=example.net
+
+# Your app will respond to:
+# myapp://profile/123 (deep link)
+# https://example.net/profile/123 (universal/app link)
+```
+
+## Domain Verification
+
+### Required Files
+
+The app stores generate the content for these files, but you must host them on your domain:
+
+#### iOS - `.well-known/apple-app-site-association`
+
+```json
+{
+  "applinks": {
+    "details": [
+      {
+        "appIDs": ["TEAM_ID.com.yourcompany.yourapp"],
+        "components": [
+          {
+            "*": "*"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+#### Android - `.well-known/assetlinks.json`
+
+```json
+[{
+  "relation": ["delegate_permission/common.handle_all_urls"],
+  "target": {
+    "namespace": "android_app",
+    "package_name": "com.yourcompany.yourapp",
+    "sha256_cert_fingerprints": ["SHA256_FINGERPRINT"]
+  }
+}]
+```
+
+### Verification Process
+
+1. **iOS**: Apple's servers periodically check the `apple-app-site-association` file
+2. **Android**: Google Play Services verifies the `assetlinks.json` file
+3. **Both**: Files must be accessible via HTTPS without redirects
+4. **Content-Type**: Serve files as `application/json`
+
+### Automatic Configuration
+
+NativePHP automatically:
+- Configures iOS `associatedDomains` in your app
+- Sets up Android `intentFilters` for your domain
+- Generates the correct fingerprints and app IDs
+- Handles platform-specific URL routing
+
+## Platform-Specific Behavior
+
+### iOS Universal Links
+
+- **Immediate**: Work as soon as the app is installed
+- **Smart Banner**: iOS can display an install banner if app isn't installed
+- **Fallback**: Opens in Safari if app isn't installed
+- **Cross-app**: Work from any app, not just Safari
+
+### Android App Links
+
+- **Verification**: Requires domain verification before working
+- **Default**: Can be set as default handler for domain links
+- **Fallback**: Opens in Chrome if app isn't installed
+- **Intent**: Uses Android's Intent system for routing
+
 ## Handling Universal/App Links
 
 Once you've configured your deep link settings, you can handle the link in your app.
@@ -93,16 +183,67 @@ https://example.net/profile/123
 ```php
 Route::get('/profile/{id}', function ($id) {
     // Handle the deep link
+    // This works for both deep links and universal/app links
 });
 ```
 
+## Testing and Development
+
+### Testing Limitations
+
+- **Development builds**: Universal/App Links may not work in development
+- **Production required**: Full testing requires production builds and domain verification
+- **Simulator**: iOS Simulator may not handle Universal Links correctly
+
+### Best Practices
+
+1. **Test both link types** - Ensure deep links and universal/app links work
+2. **Verify domain files** - Check that .well-known files are accessible
+3. **Production testing** - Test universal/app links with production builds
+4. **Fallback handling** - Ensure your website handles users without the app
+5. **Analytics tracking** - Monitor which link types are most effective
+
 ## NFC
+
 NFC is a technology that allows you to read and write NFC tags. 
 
 NativePHP handles NFC tag "bumping" just like a Universal/App Link. 
-You can use a tool like [NFC Tools](https://www.wakdev.com/en/) to test write NFC tags.
+You can use a tool like [NFC Tools](https://www.wakdev.com/en/) to write NFC tags.
 
 Set the url to a Universal/App Link and the tag will be written to the NFC tag. 
 "Bumping" the tag will open the app.
 
+### NFC Configuration
+
+NFC tags work best with Universal/App Links because:
+- They provide fallback to website if app isn't installed
+- They work across different devices and platforms
+- They provide a better user experience than custom schemes
+
+```bash
+# Write this URL to an NFC tag
+https://example.net/product/456
+
+# When "bumped":
+# - Opens your app if installed
+# - Opens website if not installed
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Universal Links not working**: Check domain verification files
+2. **Deep links not opening**: Verify URL scheme configuration
+3. **Wrong app opening**: Check for conflicting URL schemes
+4. **iOS Smart Banner**: Ensure proper app store metadata
+
+### Debug Steps
+
+1. **Verify .env configuration** - Check scheme and host values
+2. **Test deep links first** - Easier to debug than universal links
+3. **Check domain files** - Ensure .well-known files are accessible
+4. **Use production builds** - Development builds may not work correctly
+5. **Monitor app logs** - Check for link handling errors
 
+Remember that NativePHP handles all the complex platform-specific setup automatically - you just need to configure your domain and environment variables correctly.