Hybrid & Native Packaging
A Wisej.NET app doesn't have to live only in a browser tab. This course shows you how to package it as a hybrid or native application for desktop and mobile, with access to device APIs your web build can't reach. You'll learn how hybrid and native packaging works, how to reach device features like the camera, files and notifications, and how to ship to desktop and mobile app targets.
Ship your Wisej.NET app to desktop and mobile — package as hybrid and native apps with access to device APIs.
- Level: Advanced
- Duration: 5.5h
- Modules: 6
Curriculum
Module 1: Hosting Models Beyond the Browser
Module 1 of Hybrid & Native Packaging — the Wisej.NET delivery track. Read the lesson guide and the lab / exam guide, watch the hosting models walkthrough, pass the knowledge check, then complete the hands-on lab in FieldOps.
- ReadingLesson Guide · 14 min
Browser, progressive web app and Wisej.NET Hybrid — remote and local — compared across Android, iOS, Windows and macOS: architecture, offline behaviour, device access, updates and cost. What this means for a team shipping a Wisej.NET app beyond the browser tab — and how to read this module.
- ReadingLab / Exam Guide · 10 min
What you'll build in the hands-on lab, the suggested approach, and the required deliverables.
- Video lessonChoose how FieldOps reaches technicians · 14 min
Choose how FieldOps reaches technicians — a guided Module 1 walkthrough, built step by step in FieldOps. Runs right here in the player.
Narration transcript
FieldOps already runs in a browser, and that suits the dispatchers. The technicians are different: they work in vans and plant rooms, where the signal comes and goes.
There are three ways to reach them from one Wisej.NET codebase. A plain browser tab needs nothing installed. An installed progressive web app adds an icon and a window. The Wisej.NET Hybrid client is a single .NET MAUI app for Android, iOS, Windows and macOS, and it hosts FieldOps either remotely or locally.
The table compares them on five things, starting with where the code runs. In the browser, the web app and Remote mode, the handlers live on your server, so one deployment updates everyone. Local mode runs them inside the device and keeps working without a network, but every fix goes out through the stores.
The solution stays small. The FieldOps web app references the Wisej 4 Hybrid package and calls the Device class from ordinary handlers. The client project references the native package. Only if you choose Local mode do you add an offline project. The bridge between them already exists, so you never write it yourself.
On the left, the screen guesses from the user agent, and a phone browser ends up offering a camera nobody can serve. On the right, the page first asks the Device API whether the Hybrid client is really there, then whether the camera can capture. Everyone else gets an upload control, so a photo still reaches the order.
The client's startup code, which you design now and build in module three, decides the hosting mode. The Hybrid setup call names the FieldOps server as the startup address. Registering the offline startup class adds an embedded server on the device, and on Windows that needs a packaged client. The offline timeout sets when the local application takes over.
Here is one work-order list in four clients against one server. This module's build runs in the browser, which reports no Hybrid client, so it shows the upload action. Inside the Hybrid client on Windows or Android, the same check shows Take photo. One check, not a second build.
Now the signal drops. The Remote-only phone can only wait, because its handlers are on the server. The phone with a Local fallback switches to its embedded app after the timeout and keeps working on synced orders. The bill for Local: syncing those changes back, and shipping updates through the stores.
In the lab you build the three FieldOps screens in a plain browser, then write the decision record: the targets, the hosting mode, the build order and the exit criteria.
- Knowledge checkModule 1 Knowledge Check · 10 min · Pass mark 80%
- ReadingAI Coding Exercise · 20 min
Build this module's FieldOps sample with ChatGPT or Claude from a ready-made prompt that points the model at this module's specification, then review, run and extend what it gives you.
- Hands-on labLab — FieldOps Delivery Decision Record · 45 min
Objective: Create the FieldOps solution with a work-order list, a work-order detail page and a status update flow that work in a plain browser. Write the delivery decision record: compare the browser, a PWA and a Wisej.NET Hybrid client in Remote and Local mode for the technicians' needs, choose the targets, the hosting mode and the build order, and define how the app uses Device.Valid to enable device features. Deliverables: FieldOps solution with list, detail and status update; Delivery model comparison table; Delivery decision record with hosting mode and target order; Capability check design based on Device.Valid; Architecture diagram of one codebase and its clients.
Module 2: Progressive Web App Setup
Module 2 of Hybrid & Native Packaging — the Wisej.NET delivery track. Read the lesson guide and the lab / exam guide, watch the PWA setup walkthrough, pass the knowledge check, then complete the hands-on lab in FieldOps.
- ReadingLesson Guide · 14 min
Web app manifest, icons, the service worker, installability, an honest offline page and the update flow — and where a PWA stops and a Hybrid Local Application begins. What this means for a team shipping a Wisej.NET app beyond the browser tab — and how to read this module.
- ReadingLab / Exam Guide · 10 min
What you'll build in the hands-on lab, the suggested approach, and the required deliverables.
- Video lessonMake FieldOps installable as a PWA · 14 min
Make FieldOps installable as a PWA — a guided Module 2 walkthrough, built step by step in FieldOps. Runs right here in the player.
Narration transcript
Module two makes FieldOps installable: an icon on the technician's phone, a window of its own, and an offline page that is honest about a server-driven interface.
Follow one technician from full Wi-Fi at the depot to no signal at all in the plant room. A progressive web app can keep the shell on the phone, so the icon still opens. It cannot run the Wisej.NET event handlers, because they live on the server, and the server is out of reach.
Installation is a set of conditions the browser checks: a secure connection, a manifest linked from the start-up page, Default.html, a registered service worker, and the install event the page keeps for later. The manifest and the worker are ordinary web files in the web root; Wisej.NET needs no special interface for them.
The service worker treats requests differently. The shell, meaning the page, the offline page, the manifest and the icons, comes from the cache first. Wisej.NET's own scripts and everything the live session sends go straight to the network. When a page load cannot reach the server, the worker answers with the cached offline page.
On the left, the tempting version caches every response, which would replay a session the server has already forgotten into a window that looks alive. On the right, the worker matches a fixed list of shell files, lets uploads and other writes pass straight through, and falls back to the offline page only when a navigation fails.
The update half versions the cache, skips the waiting phase and claims the open page, then announces the new build. On the server, the page load writes the offline summary and reveals the install button after one good session, only when Device.Valid is false, since the Hybrid client is already installed.
Now it runs. The browser fetches the manifest, registers the worker and stores eight shell files. In Chrome or Edge, after the first session the install button appears, the page's own click opens the prompt, and FieldOps launches in a standalone window, still talking to the same server.
In the plant room, the shell loads from the cache and the last synced summary is readable, stamped ten forty-two. Status changes are switched off, not quietly queued. When the signal returns and a new build is waiting, a reload bar lets the technician finish typing first.
That honest page is the ceiling for a progressive web app. When technicians must keep working offline, the answer is a Wisej.NET Hybrid Local Application.
In the lab: the manifest and icons, a versioned worker over the shell, an install offer after one session, the offline summary page, and a working update flow.
- Knowledge checkModule 2 Knowledge Check · 10 min · Pass mark 80%
- ReadingAI Coding Exercise · 20 min
Build this module's FieldOps sample with ChatGPT or Claude from a ready-made prompt that points the model at this module's specification, then review, run and extend what it gives you.
- Hands-on labLab — FieldOps as a PWA · 45 min
Objective: Turn FieldOps into a PWA: add the manifest with icons, theme color and standalone display, register a service worker that caches the shell and static assets, show an install prompt after the first successful session, display an offline page with the last synced work-order summary when the server is unreachable, and implement the update flow that reloads when a new version is available. Deliverables: Web app manifest with icons and colors; Service worker caching the shell; Install prompt after first session; Offline page with last synced summary; Update flow and version check.
Module 3: Desktop Clients for Windows and macOS
Module 3 of Hybrid & Native Packaging — the Wisej.NET delivery track. Read the lesson guide and the lab / exam guide, watch the Windows desktop client walkthrough, pass the knowledge check, then complete the hands-on lab in FieldOps.
- ReadingLesson Guide · 14 min
The Wisej.NET Hybrid client on Windows (WebView2) and macOS (Mac Catalyst): title bar, desktop file and notification features, multiple windows and instances, remote or local hosting, and MSIX packaging. What this means for a team shipping a Wisej.NET app beyond the browser tab — and how to read this module.
- ReadingLab / Exam Guide · 10 min
What you'll build in the hands-on lab, the suggested approach, and the required deliverables.
- Video lessonShip FieldOps as a Windows desktop app · 14 min
Ship FieldOps as a Windows desktop app — a guided Module 3 walkthrough, built step by step in FieldOps. Runs right here in the player.
Narration transcript
Module three takes FieldOps out of the browser tab and into a desktop window. The same Wisej.NET application now runs inside the Hybrid client, on Windows and on the Mac.
A browser tab leaves a desktop technician short. Exported reports end up in Downloads, a new order goes unseen behind other tabs, there is no second window, and the I T team has nothing to deploy. One Hybrid client project fixes that, with WebView 2 on Windows and Mac Catalyst on mac O S.
Follow one export. The event handler on your server first confirms it is running inside the client, then asks the device file system to write the bytes. The built-in bridge carries them to the laptop, so the report lands on the technician's disk, not the server's. In a plain browser, the same button simply downloads the file.
Two files carry the whole setup. The client's startup class names the FieldOps server and sets the offline timeout. It adds the embedded fallback only when the client has an M S I X package identity, and keeps F twelve in Debug builds. Beside it, the export handler writes into the Documents folder, with a download as its fallback.
Next, decide where FieldOps runs. A remote app gets every server release at once but needs a connection. A local app runs on an embedded server inside the client and works with no network. The offline timeout combines the two, and a separate local address per instance stops desktop copies fighting over one port.
The rest is ordinary server code. When the list page loads, it writes the technician's name into the title bar and makes it visible: the client draws it as a band in its window. A new order from server push schedules a local notification. A second window opens only on the desktop, and the client project keeps trimming and ahead-of-time compilation off.
It runs on Windows, against the server on port sixty-three oh three. The title band names Dana, the export lands in Documents under FieldOps, a dispatched order raises a Windows notification, and work order forty-eight thirty opens in its own window. Each step on the right is one server call.
Now the depot Wi-Fi drops. Five seconds later the M S I X packaged client is set to switch to the Local app on its embedded server. An unpackaged client cannot host that app, so the guard keeps its runs remote only. The Mac build is the same project, compiled on a Mac.
Your lab: a Windows client with its title bar, a file export with a browser fallback, a notification and a second window, an offline fallback, and an M S I X package.
- Knowledge checkModule 3 Knowledge Check · 10 min · Pass mark 80%
- ReadingAI Coding Exercise · 20 min
Build this module's FieldOps sample with ChatGPT or Claude from a ready-made prompt that points the model at this module's specification, then review, run and extend what it gives you.
- Hands-on labLab — Windows Desktop Client · 45 min
Objective: Ship FieldOps as a Windows desktop client: a Wisej.NET Hybrid client project targeting Windows that opens the FieldOps server, sets the title bar, exports a work-order report into the technician's Documents folder with Device.FileSystem (Application.Download in a plain browser), shows a local notification when a new order arrives, opens a work order in a second window, falls back to the embedded local server after an offline timeout, and is published as an MSIX package. Deliverables: Hybrid client project targeting Windows; Report export with Device.FileSystem and a browser fallback; Local notification and a second window; Remote startup URL with a local offline fallback; MSIX package.
Module 4: Mobile Clients for Android and iOS
Module 4 of Hybrid & Native Packaging — the Wisej.NET delivery track. Read the lesson guide and the lab / exam guide, watch the Android and iOS client walkthrough, pass the knowledge check, then complete the hands-on lab in FieldOps.
- ReadingLesson Guide · 14 min
The Wisej.NET Hybrid client on Android and iOS: the client project and Startup.cs, required build settings, lifecycle and the back gesture, native permissions and the emulator and device build loop. What this means for a team shipping a Wisej.NET app beyond the browser tab — and how to read this module.
- ReadingLab / Exam Guide · 10 min
What you'll build in the hands-on lab, the suggested approach, and the required deliverables.
- Video lessonRun FieldOps on Android and iOS · 14 min
Run FieldOps on Android and iOS — a guided Module 4 walkthrough, built step by step in FieldOps. Runs right here in the player.
Narration transcript
This is Module 4 of Hybrid and Native Packaging. FieldOps stays on its server, and a Wisej.NET Hybrid client brings it to Android and iOS phones, adding one phone-shaped page and rewriting nothing.
A browser tab gives technicians no icon, no store channel and no route to the device. The phone is a demanding host. A phone call pushes the app into the background, the client reloads its web view by default when the app returns, and Android adds a system back gesture that iOS does not have.
The solution has two halves. The FieldOps application references the Wisej four Hybrid package and calls the Device API from ordinary server-side code. The mobile client, created from the Hybrid Client Application template, references the native package. You never write the bridge yourself: the web view and the client already handle every device request.
The client's startup class is its whole configuration. It registers Wisej.NET Hybrid on the app builder and takes the startup address from one class, so debug builds reach your machine and release builds reach production. The project file switches off trimming, linking and ahead-of-time compilation, which Hybrid does not support yet.
When the technician takes a call, the Backgrounding event saves the open work order and its draft reading. On return, the client reloads the page by default. Keeping that gives a fresh screen with the latest server code; turning it off gives an instant return, but only when nothing was lost. Either way, restore from what you saved.
These handlers live in the Wisej.NET application, not in the client. The lifecycle events save and restore the draft through the device preferences. The back request event sends Android's back gesture into one navigation method: close a dialog first, then confirm unsaved changes, then return from the detail page to the list.
Restore the workloads once, then build and run for Android on the emulator, and for iOS on the Simulator, which needs a Mac with Xcode. The emulator reaches your computer at ten dot zero dot two dot two, and Chrome or Safari lets you inspect the running page.
This is the path FieldOps is built for on a phone. A call interrupts the reading, the draft is saved, and the page reloads on return with work order forty-eight twenty-one and its reading intact. A back swipe asks first. On Windows, minimising raises Stopped and keeps the page.
In the lab you build this client: the startup configuration and build settings, lifecycle handling with draft restore, back navigation inside FieldOps, and screenshots on both platforms.
- Knowledge checkModule 4 Knowledge Check · 10 min · Pass mark 80%
- ReadingAI Coding Exercise · 20 min
Build this module's FieldOps sample with ChatGPT or Claude from a ready-made prompt that points the model at this module's specification, then review, run and extend what it gives you.
- Hands-on labLab — Mobile Hybrid Client · 45 min
Objective: Build the FieldOps mobile client: a Wisej.NET Hybrid client project targeting Android and iOS whose Startup.cs points at the FieldOps server, the trimming and AOT settings the packages require, Device.Lifecycle handlers that save the open work order when the app goes to the background and restore it on resume, Device.Application.BackRequested routed to FieldOps' own navigation, and a debug build running on one emulator or simulator per platform with screenshots of the work-order list. Deliverables: Hybrid client project for Android and iOS; Startup.cs and the required build settings; Lifecycle handling with draft restore; Back gesture mapped to in-app navigation; Emulator builds and screenshots for both platforms.
Module 5: Device APIs with Wisej.Hybrid.Device
Module 5 of Hybrid & Native Packaging — the Wisej.NET delivery track. Read the lesson guide and the lab / exam guide, watch the device APIs walkthrough, pass the knowledge check, then complete the hands-on lab in FieldOps.
- ReadingLesson Guide · 14 min
Camera, location, maps, local notifications, secure storage and biometrics called from server-side C# through Wisej.Hybrid.Device, with Device.Valid checks, permission handling and browser fallbacks. What this means for a team shipping a Wisej.NET app beyond the browser tab — and how to read this module.
- ReadingLab / Exam Guide · 10 min
What you'll build in the hands-on lab, the suggested approach, and the required deliverables.
- Video lessonCapture photos and locations from FieldOps · 14 min
Capture photos and locations from FieldOps — a guided Module 5 walkthrough, built step by step in FieldOps. Runs right here in the player.
Narration transcript
Welcome to Module 5. A FieldOps technician needs the phone's camera and location, yet every control in the app is a C sharp object running on your server.
Here is the whole trip. The click handler on the server awaits Device.Media to capture a photo. The built-in bridge carries that call into the Hybrid client, which opens the camera and shrinks the picture on the device. When the await completes, you get the image back, or nothing at all if the technician cancelled.
Before offering any of this, the screen asks one question: is the Hybrid client really there? Device.Valid answers it, and it is false in a browser and in an installed progressive web app. Refine it per feature, for example whether this device can capture at all. In a browser, the Upload control covers photos.
Permissions come at the moment of use. When Navigate is pressed, show one sentence of reason, then let Device.Permissions check and request. A first refusal keeps the action for next time. A final refusal switches to the manual path and offers the app's settings page, without nagging again.
Now the code. The photo handler first confirms the client and its camera, then asks for permission. It captures at sixteen hundred pixels and seventy percent quality, so the phone does the resizing. A null result simply means cancelled. The image is stored, disposed, and the thumbnail is pushed back to the screen.
A single helper owns every permission prompt and logs each outcome. Navigate reads one location fix with high accuracy and a ten second timeout, records it with the server's own time, then opens the maps app. A local notification reminds the technician half an hour before the next job.
In the Hybrid client, each handler leaves the screen in a clear state. While the camera is open, a banner says the server waits. A stored photo appears as a thumbnail, the signature is saved under the typed name, and Navigate stamps the arrival before the maps application opens.
Open the same screen in a plain browser and the device flag is false. Upload takes the photo and a maps link opens the route. Remote push notifications are not part of Hybrid four point one point seven, so server push keeps the job list current instead.
Your lab: add Take Photo with an upload fallback, a signature, Navigate with the maps hand-off, a local reminder, and careful permission handling across every client.
- Knowledge checkModule 5 Knowledge Check · 10 min · Pass mark 80%
- ReadingAI Coding Exercise · 20 min
Build this module's FieldOps sample with ChatGPT or Claude from a ready-made prompt that points the model at this module's specification, then review, run and extend what it gives you.
- Hands-on labLab — Camera, Location and Notifications · 45 min
Objective: Add device features to FieldOps: a Take Photo action that uses Device.Media in the Hybrid client and falls back to an Upload control in the browser, a signature capture uploaded as an image, a Navigate action that reads the location with Device.Geolocation and opens the maps app with Device.Map, a local notification reminder before the next appointment, and permission handling with Device.Permissions that explains, asks and degrades gracefully. Deliverables: Camera capture with browser upload fallback; Signature capture and upload; Geolocation and maps hand-off; Local notification reminder; Permission handling and capability matrix.
Module 6: Signing, Distribution, Updates and the FieldOps Capstone
Module 6 of Hybrid & Native Packaging — the Wisej.NET delivery track. Read the lesson guide and the lab / exam guide, watch the signing and distribution walkthrough, pass the knowledge check, then complete the hands-on lab in FieldOps.
- ReadingLesson Guide · 14 min
Code signing, store submission, enterprise distribution, versioning, update strategies for remote and local Hybrid apps, telemetry and the capstone delivery. What this means for a team shipping a Wisej.NET app beyond the browser tab — and how to read this module.
- ReadingLab / Exam Guide · 10 min
What you'll build in the hands-on lab, the suggested approach, and the required deliverables.
- Video lessonSign, distribute and update every FieldOps client · 14 min
Sign, distribute and update every FieldOps client — a guided Module 6 walkthrough, built step by step in FieldOps. Runs right here in the player.
Narration transcript
This is the FieldOps capstone. One Wisej.NET application reaches the browser, the installed web app and Hybrid clients on four platforms, and each client package needs a trusted signature.
A server deployment alone does not make a release. On this release day the server went live early, yet the Windows package was rejected because its publisher was unknown, the iPhone build carried an expired provisioning profile, and an older Android client never registered the authentication extension that the new server now relies on.
Signing differs per platform. Windows uses a code-signing certificate plus a timestamp, so the package outlives the certificate. Android signs with an upload key while Google holds the app signing key. Apple pairs a distribution certificate with a provisioning profile, built on a Mac. Every package is published from the Hybrid client project in Release.
Distribution is one decision per platform. Because technicians use company-managed devices, FieldOps goes out privately: managed Google Play for Android, Apple Business Manager for iPhones and Macs, and Intune or the Microsoft Store for Windows. The browser and the installed web app skip all of this, with no certificate and no review.
Displaying a version number protects nothing. The real check runs on the server: once Device.Valid confirms a Hybrid client, the app reads the connected client version from Device.Versioning and the platform from Device.System, compares them with that platform's minimum, and then admits the client, shows a notice, or sends it to the store.
Telemetry has to cover both ends. Wisej.NET Hybrid ships no crash reporting of its own, so the client project installs a small crash hook, and the log address in its configuration sends client logs to the same server endpoint. On the server, every device feature records an event with its outcome, platform, model and client version.
Here the Windows client, version two point six, meets three policies. When current, it is admitted and shows what is new. When two point seven is the latest, it gets a notice and keeps working. When two point seven is the minimum, it stops at the update screen. A browser session never needs the check.
The release checklist gives every delivery its own column. For Remote clients a server deployment is the release, unless the client project itself changed; Local clients always need a signed store release. A week of usage events then shows location being denied too often, which points to a badly timed permission prompt.
For the lab, sign the three packages, plan enterprise distribution with a listing draft, add the startup version check, wire up crash and usage telemetry, and hand over the checklist.
- Knowledge checkModule 6 Knowledge Check · 10 min · Pass mark 80%
- ReadingAI Coding Exercise · 20 min
Build this module's FieldOps sample with ChatGPT or Claude from a ready-made prompt that points the model at this module's specification, then review, run and extend what it gives you.
- Hands-on labLab — Signing and Release Capstone · 45 min
Objective: Complete the FieldOps capstone: sign the Windows MSIX and the Android and iOS packages, prepare an enterprise distribution for the mobile clients and a store listing draft, define a compatibility rule between server versions and client versions checked on startup with Device.Versioning, add crash reporting and a usage event for each device feature, and deliver a release checklist covering the browser, the PWA and every Hybrid client. Deliverables: Signed Windows, Android and iOS packages; Enterprise distribution setup and store listing draft; Server and client version compatibility check; Crash and usage telemetry; Release checklist for every delivery model.