Native operating system drag and drop, carrying the clipboard's own payload

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -80,6 +80,7 @@
 importcom.codename1.ui.CN;
 importcom.codename1.ui.Command;
 importcom.codename1.ui.ClipboardContent;
+importcom.codename1.ui.NativeDragOperation;
 importcom.codename1.ui.Component;
 importcom.codename1.ui.Container;
 importcom.codename1.ui.Dialog;
@@ -5566,6 +5567,117 @@ public void installNativeTheme() {
 thrownewRuntimeException();
  }
 
+// ------------------------------------------------------------------------------------
+// Native (operating system) drag and drop. The payload is a ClipboardContent, the same one
+// copyToClipboard publishes, because a drag is a copy the user aims with the pointer.
+//
+// A port implements the outbound half here and calls
+// com.codename1.ui.NativeDragAndDrop for the inbound half.
+// ------------------------------------------------------------------------------------
+
+/// Returns true when this platform can hand a drag to the operating system. False here
+/// leaves the framework with only its lightweight in-form drag and drop, which is what
+/// every port had before.
+///
+/// #### Returns
+///
+/// true when native drag and drop is available
+publicbooleanisNativeDragAndDropSupported() {
+returnfalse;
+ }
+
+/// Returns true when a drag started in this application can be dropped outside it -- on the
+/// desktop, in a file manager, or in another application's window. Ports that can route a
+/// drag between their own components but not out of the application return false while
+/// still returning true from `#isNativeDragAndDropSupported()`.
+///
+/// #### Returns
+///
+/// true when a drag can leave the application
+publicbooleanisNativeDragOutsideApplicationSupported() {
+returnisNativeDragAndDropSupported();
+ }
+
+/// Hands the port the drag that would start if the press currently down turns into a drag.
+///
+/// Ports whose platform owns the gesture -- where the operating system's own recognizer
+/// decides a drag has begun and then asks what is being dragged -- answer from what they
+/// were given here. Ports that start the session themselves can ignore this and use
+/// `#startNativeDrag(com.codename1.ui.NativeDragOperation)`.
+///
+/// Invoked on the event dispatch thread, once per press. A press that produces no drag is
+/// followed by `#cancelNativeDrag()`.
+///
+/// #### Parameters
+///
+/// - `op`: the drag that is now possible
+publicvoidprepareNativeDrag(NativeDragOperationop) {
+ }
+
+/// Starts a native drag session now, because the pointer has moved far enough to be a drag.
+/// Invoked on the event dispatch thread while the pointer is still down.
+///
+/// A port that starts the session must eventually report the outcome through
+/// `com.codename1.ui.NativeDragAndDrop#dragCompleted(int)`, or a source that offered a move
+/// never learns whether to delete its copy.
+///
+/// #### Parameters
+///
+/// - `op`: what is being dragged
+///
+/// #### Returns
+///
+/// true when the operating system took the drag
+publicbooleanstartNativeDrag(NativeDragOperationop) {
+returnfalse;
+ }
+
+/// Discards whatever `#prepareNativeDrag(com.codename1.ui.NativeDragOperation)` staged,
+/// because the press turned out to be a click.
+publicvoidcancelNativeDrag() {
+ }
+
+/// Notifies the port that the application has a component that can be dragged through the
+/// operating system.
+///
+/// A platform whose drag gesture is its own -- UIKit's is -- recognizes that gesture with a
+/// recognizer installed on the surface, and installing one changes how every touch on that
+/// surface is delivered. Doing it unconditionally would alter touch handling for every
+/// application, including the overwhelming majority that never drags anything; a port that
+/// needs a recognizer therefore installs it here, the first time an application says it
+/// wants one.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDragSourceRegistered() {
+ }
+
+/// Notifies the port that the application has a component that accepts drops from the
+/// operating system.
+///
+/// The counterpart of `#nativeDragSourceRegistered()`, for the same reason: a port attaches
+/// whatever the platform needs in order to receive drops only for applications that asked
+/// to receive them, so an application that never does keeps exactly the input handling it
+/// had.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDropTargetRegistered() {
+ }
+
+/// True when the port needs the drag image at the moment the operation is staged rather
+/// than when the drag begins.
+///
+/// A port that starts the session itself renders the image then, which costs nothing for a
+/// press that turns out to be a click. A port whose platform owns the drag gesture is asked
+/// for the preview from inside that platform's own callback, which is not a moment at which
+/// a component can be rendered, so it has to have the image already.
+///
+/// #### Returns
+///
+/// true to render the drag image on every press over a native drag source
+publicbooleanisNativeDragImageNeededOnPrepare() {
+returnfalse;
+ }
+
 /// Performs a clipboard copy operation, if the native clipboard is supported by the implementation it would be used
 ///
 /// #### Parameters

CodenameOne/src/com/codename1/ui/ClipboardContent.java

@@ -46,12 +46,40 @@ public class ClipboardContent {
 publicstaticfinalStringMIME_GIF = "image/gif";
 /// A local file reference (a file path / URI `String`, or a `String[]` for several files).
 publicstaticfinalStringMIME_FILE = "application/x-file-list";
+/// A newline separated list of URIs, the format desktop browsers and file managers use when
+/// a link or a file is dragged out of them.
+publicstaticfinalStringMIME_URI_LIST = "text/uri-list";
 
 privatefinalList<String> mimeTypes = newArrayList<String>();
 privatefinalList<Object> values = newArrayList<Object>();
 
 /// Adds or replaces a representation. Passing null removes the MIME type.
 publicClipboardContentsetData(StringmimeType, Objectvalue) {
+returnput(mimeType, value);
+ }
+
+/// Declares a representation that is only built if something reads it, which is how a drag
+/// offers a file it has not written yet or an image it has not encoded yet.
+///
+/// The provider is asked at most once and its answer is then cached, so
+/// `#getData(java.lang.String)` behaves exactly as it would for a value passed to
+/// `#setData(java.lang.String, java.lang.Object)`. It may run on a native clipboard or drag
+/// thread; see `ClipboardDataProvider`. Passing a null provider removes the MIME type.
+///
+/// #### Parameters
+///
+/// - `mimeType`: the MIME type this provider can produce
+///
+/// - `provider`: the provider, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetDataProvider(StringmimeType, ClipboardDataProviderprovider) {
+returnput(mimeType, provider == null ? null : newLazyValue(provider));
+ }
+
+privateClipboardContentput(StringmimeType, Objectvalue) {
 Stringnormalized = normalizeMimeType(mimeType);
 if (normalized.length() == 0) {
 thrownewIllegalArgumentException("MIME type must not be empty");
@@ -74,9 +102,41 @@ public ClipboardContent setData(String mimeType, Object value) {
  }
 
 /// Returns the representation for a MIME type, or null when it isn't available.
+///
+/// A representation registered through
+/// `#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)` is produced
+/// here, on the first call for that MIME type.
 publicObjectgetData(StringmimeType) {
 intindex = mimeTypes.indexOf(normalizeMimeType(mimeType));
-returnindex < 0 ? null : values.get(index);
+if (index < 0) {
+returnnull;
+ }
+Objectvalue = values.get(index);
+if (valueinstanceofLazyValue) {
+return ((LazyValue) value).resolve(mimeTypes.get(index));
+ }
+returnvalue;
+ }
+
+/// A provider plus the value it produced. The value is resolved once and remembered, so a
+/// target that asks twice -- as a drop does when it queries and then reads -- does not run
+/// the provider twice and does not, for instance, write the promised file twice.
+privatestaticfinalclassLazyValue {
+privatefinalClipboardDataProviderprovider;
+privateObjectresolved;
+privatebooleandone;
+
+LazyValue(ClipboardDataProviderprovider) {
+this.provider = provider;
+ }
+
+synchronizedObjectresolve(StringmimeType) {
+if (!done) {
+done = true;
+resolved = provider.getClipboardData(mimeType);
+ }
+returnresolved;
+ }
  }
 
 /// Returns the binary (`byte[]`) representation for a MIME type -- e.g. the raw bytes of an image
@@ -102,6 +162,43 @@ public String[] getMimeTypes() {
 returnmimeTypes.toArray(newString[mimeTypes.size()]);
  }
 
+/// Sets the `#MIME_FILE` representation from a list of file paths or `file:` URIs.
+///
+/// Ports differ on whether a single file is carried as a `String` or a one element
+/// `String[]`; this writes the form the rest of the framework expects, and
+/// `#getFiles()` reads either.
+///
+/// #### Parameters
+///
+/// - `paths`: the file paths, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetFiles(String[] paths) {
+if (paths == null || paths.length == 0) {
+returnsetData(MIME_FILE, null);
+ }
+if (paths.length == 1) {
+returnsetData(MIME_FILE, paths[0]);
+ }
+returnsetData(MIME_FILE, paths.clone());
+ }
+
+/// Returns the `#MIME_FILE` representation as a path array regardless of whether the
+/// producer stored one `String` or a `String[]`, or null when no files are available.
+publicString[] getFiles() {
+Objectvalue = getData(MIME_FILE);
+if (valueinstanceofString[]) {
+String[] paths = (String[]) value;
+returnpaths.length == 0 ? null : paths.clone();
+ }
+if (valueinstanceofString && ((String) value).length() > 0) {
+returnnewString[] { (String) value };
+ }
+returnnull;
+ }
+
 /// Returns the first available MIME type from the caller's preference list, or null.
 publicStringfindPreferredMimeType(String[] preferredMimeTypes) {
 if (preferredMimeTypes == null) {

CodenameOne/src/com/codename1/ui/ClipboardDataProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+
+package com.codename1.ui;
+
+/// Produces a clipboard or drag-and-drop representation on demand, so a payload that is
+/// expensive to build is only built if something actually asks for it.
+///
+/// This is what makes "drag a file out of the application" workable. A drag that offers
+/// `ClipboardContent#MIME_FILE` has to name the file when the drag *starts*, but the drop may
+/// never happen -- the user may let go over nothing -- and the target may prefer a different
+/// representation entirely. Registering a provider with
+/// `ClipboardContent#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)`
+/// declares that the representation is available without paying for it up front; the bytes are
+/// written, or the temporary file created, at the moment the receiving application reads that
+/// MIME type.
+///
+/// A provider is invoked at most once per `ClipboardContent` and MIME type -- the result is
+/// cached -- and it may be invoked from a native drag or clipboard thread rather than the event
+/// dispatch thread, so it must not touch the user interface.
+///
+/// #### When it actually runs
+///
+/// On the desktop and on iOS the provider runs when a receiver reads that representation, so a
+/// drag the user abandons costs nothing. Android is the exception: `startDragAndDrop` takes a
+/// complete clip, and a clip carries text or a reference to a file that already exists, so
+/// every provider runs as the drag begins. A drag out of an iOS application resolves its *file
+/// list* at the same moment for a related reason -- the system needs the number of items the
+/// drag carries, and for a file drag that is the number of files.
+///
+/// So a provider should be cheap enough to run once per drag, and must not assume it will only
+/// run when its data is wanted.
+public interface ClipboardDataProvider {
+ /// Produces the value for one representation.
+ ///
+ /// #### Parameters
+ ///
+ /// - `mimeType`: the MIME type being requested, always one this provider was registered for
+ ///
+ /// #### Returns
+ ///
+ /// the value, normally a `String`, a `String[]` of file paths or a `byte[]`, or null when
+ /// the representation turned out to be unavailable
+ Object getClipboardData(String mimeType);
+}

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -80,6 +80,7 @@
 importcom.codename1.ui.CN;
 importcom.codename1.ui.Command;
 importcom.codename1.ui.ClipboardContent;
+importcom.codename1.ui.NativeDragOperation;
 importcom.codename1.ui.Component;
 importcom.codename1.ui.Container;
 importcom.codename1.ui.Dialog;
@@ -5566,6 +5567,117 @@ public void installNativeTheme() {
 thrownewRuntimeException();
  }
 
+// ------------------------------------------------------------------------------------
+// Native (operating system) drag and drop. The payload is a ClipboardContent, the same one
+// copyToClipboard publishes, because a drag is a copy the user aims with the pointer.
+//
+// A port implements the outbound half here and calls
+// com.codename1.ui.NativeDragAndDrop for the inbound half.
+// ------------------------------------------------------------------------------------
+
+/// Returns true when this platform can hand a drag to the operating system. False here
+/// leaves the framework with only its lightweight in-form drag and drop, which is what
+/// every port had before.
+///
+/// #### Returns
+///
+/// true when native drag and drop is available
+publicbooleanisNativeDragAndDropSupported() {
+returnfalse;
+ }
+
+/// Returns true when a drag started in this application can be dropped outside it -- on the
+/// desktop, in a file manager, or in another application's window. Ports that can route a
+/// drag between their own components but not out of the application return false while
+/// still returning true from `#isNativeDragAndDropSupported()`.
+///
+/// #### Returns
+///
+/// true when a drag can leave the application
+publicbooleanisNativeDragOutsideApplicationSupported() {
+returnisNativeDragAndDropSupported();
+ }
+
+/// Hands the port the drag that would start if the press currently down turns into a drag.
+///
+/// Ports whose platform owns the gesture -- where the operating system's own recognizer
+/// decides a drag has begun and then asks what is being dragged -- answer from what they
+/// were given here. Ports that start the session themselves can ignore this and use
+/// `#startNativeDrag(com.codename1.ui.NativeDragOperation)`.
+///
+/// Invoked on the event dispatch thread, once per press. A press that produces no drag is
+/// followed by `#cancelNativeDrag()`.
+///
+/// #### Parameters
+///
+/// - `op`: the drag that is now possible
+publicvoidprepareNativeDrag(NativeDragOperationop) {
+ }
+
+/// Starts a native drag session now, because the pointer has moved far enough to be a drag.
+/// Invoked on the event dispatch thread while the pointer is still down.
+///
+/// A port that starts the session must eventually report the outcome through
+/// `com.codename1.ui.NativeDragAndDrop#dragCompleted(int)`, or a source that offered a move
+/// never learns whether to delete its copy.
+///
+/// #### Parameters
+///
+/// - `op`: what is being dragged
+///
+/// #### Returns
+///
+/// true when the operating system took the drag
+publicbooleanstartNativeDrag(NativeDragOperationop) {
+returnfalse;
+ }
+
+/// Discards whatever `#prepareNativeDrag(com.codename1.ui.NativeDragOperation)` staged,
+/// because the press turned out to be a click.
+publicvoidcancelNativeDrag() {
+ }
+
+/// Notifies the port that the application has a component that can be dragged through the
+/// operating system.
+///
+/// A platform whose drag gesture is its own -- UIKit's is -- recognizes that gesture with a
+/// recognizer installed on the surface, and installing one changes how every touch on that
+/// surface is delivered. Doing it unconditionally would alter touch handling for every
+/// application, including the overwhelming majority that never drags anything; a port that
+/// needs a recognizer therefore installs it here, the first time an application says it
+/// wants one.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDragSourceRegistered() {
+ }
+
+/// Notifies the port that the application has a component that accepts drops from the
+/// operating system.
+///
+/// The counterpart of `#nativeDragSourceRegistered()`, for the same reason: a port attaches
+/// whatever the platform needs in order to receive drops only for applications that asked
+/// to receive them, so an application that never does keeps exactly the input handling it
+/// had.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDropTargetRegistered() {
+ }
+
+/// True when the port needs the drag image at the moment the operation is staged rather
+/// than when the drag begins.
+///
+/// A port that starts the session itself renders the image then, which costs nothing for a
+/// press that turns out to be a click. A port whose platform owns the drag gesture is asked
+/// for the preview from inside that platform's own callback, which is not a moment at which
+/// a component can be rendered, so it has to have the image already.
+///
+/// #### Returns
+///
+/// true to render the drag image on every press over a native drag source
+publicbooleanisNativeDragImageNeededOnPrepare() {
+returnfalse;
+ }
+
 /// Performs a clipboard copy operation, if the native clipboard is supported by the implementation it would be used
 ///
 /// #### Parameters

CodenameOne/src/com/codename1/ui/ClipboardContent.java

@@ -46,12 +46,40 @@ public class ClipboardContent {
 publicstaticfinalStringMIME_GIF = "image/gif";
 /// A local file reference (a file path / URI `String`, or a `String[]` for several files).
 publicstaticfinalStringMIME_FILE = "application/x-file-list";
+/// A newline separated list of URIs, the format desktop browsers and file managers use when
+/// a link or a file is dragged out of them.
+publicstaticfinalStringMIME_URI_LIST = "text/uri-list";
 
 privatefinalList<String> mimeTypes = newArrayList<String>();
 privatefinalList<Object> values = newArrayList<Object>();
 
 /// Adds or replaces a representation. Passing null removes the MIME type.
 publicClipboardContentsetData(StringmimeType, Objectvalue) {
+returnput(mimeType, value);
+ }
+
+/// Declares a representation that is only built if something reads it, which is how a drag
+/// offers a file it has not written yet or an image it has not encoded yet.
+///
+/// The provider is asked at most once and its answer is then cached, so
+/// `#getData(java.lang.String)` behaves exactly as it would for a value passed to
+/// `#setData(java.lang.String, java.lang.Object)`. It may run on a native clipboard or drag
+/// thread; see `ClipboardDataProvider`. Passing a null provider removes the MIME type.
+///
+/// #### Parameters
+///
+/// - `mimeType`: the MIME type this provider can produce
+///
+/// - `provider`: the provider, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetDataProvider(StringmimeType, ClipboardDataProviderprovider) {
+returnput(mimeType, provider == null ? null : newLazyValue(provider));
+ }
+
+privateClipboardContentput(StringmimeType, Objectvalue) {
 Stringnormalized = normalizeMimeType(mimeType);
 if (normalized.length() == 0) {
 thrownewIllegalArgumentException("MIME type must not be empty");
@@ -74,9 +102,41 @@ public ClipboardContent setData(String mimeType, Object value) {
  }
 
 /// Returns the representation for a MIME type, or null when it isn't available.
+///
+/// A representation registered through
+/// `#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)` is produced
+/// here, on the first call for that MIME type.
 publicObjectgetData(StringmimeType) {
 intindex = mimeTypes.indexOf(normalizeMimeType(mimeType));
-returnindex < 0 ? null : values.get(index);
+if (index < 0) {
+returnnull;
+ }
+Objectvalue = values.get(index);
+if (valueinstanceofLazyValue) {
+return ((LazyValue) value).resolve(mimeTypes.get(index));
+ }
+returnvalue;
+ }
+
+/// A provider plus the value it produced. The value is resolved once and remembered, so a
+/// target that asks twice -- as a drop does when it queries and then reads -- does not run
+/// the provider twice and does not, for instance, write the promised file twice.
+privatestaticfinalclassLazyValue {
+privatefinalClipboardDataProviderprovider;
+privateObjectresolved;
+privatebooleandone;
+
+LazyValue(ClipboardDataProviderprovider) {
+this.provider = provider;
+ }
+
+synchronizedObjectresolve(StringmimeType) {
+if (!done) {
+done = true;
+resolved = provider.getClipboardData(mimeType);
+ }
+returnresolved;
+ }
  }
 
 /// Returns the binary (`byte[]`) representation for a MIME type -- e.g. the raw bytes of an image
@@ -102,6 +162,43 @@ public String[] getMimeTypes() {
 returnmimeTypes.toArray(newString[mimeTypes.size()]);
  }
 
+/// Sets the `#MIME_FILE` representation from a list of file paths or `file:` URIs.
+///
+/// Ports differ on whether a single file is carried as a `String` or a one element
+/// `String[]`; this writes the form the rest of the framework expects, and
+/// `#getFiles()` reads either.
+///
+/// #### Parameters
+///
+/// - `paths`: the file paths, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetFiles(String[] paths) {
+if (paths == null || paths.length == 0) {
+returnsetData(MIME_FILE, null);
+ }
+if (paths.length == 1) {
+returnsetData(MIME_FILE, paths[0]);
+ }
+returnsetData(MIME_FILE, paths.clone());
+ }
+
+/// Returns the `#MIME_FILE` representation as a path array regardless of whether the
+/// producer stored one `String` or a `String[]`, or null when no files are available.
+publicString[] getFiles() {
+Objectvalue = getData(MIME_FILE);
+if (valueinstanceofString[]) {
+String[] paths = (String[]) value;
+returnpaths.length == 0 ? null : paths.clone();
+ }
+if (valueinstanceofString && ((String) value).length() > 0) {
+returnnewString[] { (String) value };
+ }
+returnnull;
+ }
+
 /// Returns the first available MIME type from the caller's preference list, or null.
 publicStringfindPreferredMimeType(String[] preferredMimeTypes) {
 if (preferredMimeTypes == null) {

CodenameOne/src/com/codename1/ui/ClipboardDataProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+
+package com.codename1.ui;
+
+/// Produces a clipboard or drag-and-drop representation on demand, so a payload that is
+/// expensive to build is only built if something actually asks for it.
+///
+/// This is what makes "drag a file out of the application" workable. A drag that offers
+/// `ClipboardContent#MIME_FILE` has to name the file when the drag *starts*, but the drop may
+/// never happen -- the user may let go over nothing -- and the target may prefer a different
+/// representation entirely. Registering a provider with
+/// `ClipboardContent#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)`
+/// declares that the representation is available without paying for it up front; the bytes are
+/// written, or the temporary file created, at the moment the receiving application reads that
+/// MIME type.
+///
+/// A provider is invoked at most once per `ClipboardContent` and MIME type -- the result is
+/// cached -- and it may be invoked from a native drag or clipboard thread rather than the event
+/// dispatch thread, so it must not touch the user interface.
+///
+/// #### When it actually runs
+///
+/// On the desktop and on iOS the provider runs when a receiver reads that representation, so a
+/// drag the user abandons costs nothing. Android is the exception: `startDragAndDrop` takes a
+/// complete clip, and a clip carries text or a reference to a file that already exists, so
+/// every provider runs as the drag begins. A drag out of an iOS application resolves its *file
+/// list* at the same moment for a related reason -- the system needs the number of items the
+/// drag carries, and for a file drag that is the number of files.
+///
+/// So a provider should be cheap enough to run once per drag, and must not assume it will only
+/// run when its data is wanted.
+public interface ClipboardDataProvider {
+ /// Produces the value for one representation.
+ ///
+ /// #### Parameters
+ ///
+ /// - `mimeType`: the MIME type being requested, always one this provider was registered for
+ ///
+ /// #### Returns
+ ///
+ /// the value, normally a `String`, a `String[]` of file paths or a `byte[]`, or null when
+ /// the representation turned out to be unavailable
+ Object getClipboardData(String mimeType);
+}

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -80,6 +80,7 @@
 importcom.codename1.ui.CN;
 importcom.codename1.ui.Command;
 importcom.codename1.ui.ClipboardContent;
+importcom.codename1.ui.NativeDragOperation;
 importcom.codename1.ui.Component;
 importcom.codename1.ui.Container;
 importcom.codename1.ui.Dialog;
@@ -5566,6 +5567,117 @@ public void installNativeTheme() {
 thrownewRuntimeException();
  }
 
+// ------------------------------------------------------------------------------------
+// Native (operating system) drag and drop. The payload is a ClipboardContent, the same one
+// copyToClipboard publishes, because a drag is a copy the user aims with the pointer.
+//
+// A port implements the outbound half here and calls
+// com.codename1.ui.NativeDragAndDrop for the inbound half.
+// ------------------------------------------------------------------------------------
+
+/// Returns true when this platform can hand a drag to the operating system. False here
+/// leaves the framework with only its lightweight in-form drag and drop, which is what
+/// every port had before.
+///
+/// #### Returns
+///
+/// true when native drag and drop is available
+publicbooleanisNativeDragAndDropSupported() {
+returnfalse;
+ }
+
+/// Returns true when a drag started in this application can be dropped outside it -- on the
+/// desktop, in a file manager, or in another application's window. Ports that can route a
+/// drag between their own components but not out of the application return false while
+/// still returning true from `#isNativeDragAndDropSupported()`.
+///
+/// #### Returns
+///
+/// true when a drag can leave the application
+publicbooleanisNativeDragOutsideApplicationSupported() {
+returnisNativeDragAndDropSupported();
+ }
+
+/// Hands the port the drag that would start if the press currently down turns into a drag.
+///
+/// Ports whose platform owns the gesture -- where the operating system's own recognizer
+/// decides a drag has begun and then asks what is being dragged -- answer from what they
+/// were given here. Ports that start the session themselves can ignore this and use
+/// `#startNativeDrag(com.codename1.ui.NativeDragOperation)`.
+///
+/// Invoked on the event dispatch thread, once per press. A press that produces no drag is
+/// followed by `#cancelNativeDrag()`.
+///
+/// #### Parameters
+///
+/// - `op`: the drag that is now possible
+publicvoidprepareNativeDrag(NativeDragOperationop) {
+ }
+
+/// Starts a native drag session now, because the pointer has moved far enough to be a drag.
+/// Invoked on the event dispatch thread while the pointer is still down.
+///
+/// A port that starts the session must eventually report the outcome through
+/// `com.codename1.ui.NativeDragAndDrop#dragCompleted(int)`, or a source that offered a move
+/// never learns whether to delete its copy.
+///
+/// #### Parameters
+///
+/// - `op`: what is being dragged
+///
+/// #### Returns
+///
+/// true when the operating system took the drag
+publicbooleanstartNativeDrag(NativeDragOperationop) {
+returnfalse;
+ }
+
+/// Discards whatever `#prepareNativeDrag(com.codename1.ui.NativeDragOperation)` staged,
+/// because the press turned out to be a click.
+publicvoidcancelNativeDrag() {
+ }
+
+/// Notifies the port that the application has a component that can be dragged through the
+/// operating system.
+///
+/// A platform whose drag gesture is its own -- UIKit's is -- recognizes that gesture with a
+/// recognizer installed on the surface, and installing one changes how every touch on that
+/// surface is delivered. Doing it unconditionally would alter touch handling for every
+/// application, including the overwhelming majority that never drags anything; a port that
+/// needs a recognizer therefore installs it here, the first time an application says it
+/// wants one.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDragSourceRegistered() {
+ }
+
+/// Notifies the port that the application has a component that accepts drops from the
+/// operating system.
+///
+/// The counterpart of `#nativeDragSourceRegistered()`, for the same reason: a port attaches
+/// whatever the platform needs in order to receive drops only for applications that asked
+/// to receive them, so an application that never does keeps exactly the input handling it
+/// had.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDropTargetRegistered() {
+ }
+
+/// True when the port needs the drag image at the moment the operation is staged rather
+/// than when the drag begins.
+///
+/// A port that starts the session itself renders the image then, which costs nothing for a
+/// press that turns out to be a click. A port whose platform owns the drag gesture is asked
+/// for the preview from inside that platform's own callback, which is not a moment at which
+/// a component can be rendered, so it has to have the image already.
+///
+/// #### Returns
+///
+/// true to render the drag image on every press over a native drag source
+publicbooleanisNativeDragImageNeededOnPrepare() {
+returnfalse;
+ }
+
 /// Performs a clipboard copy operation, if the native clipboard is supported by the implementation it would be used
 ///
 /// #### Parameters

CodenameOne/src/com/codename1/ui/ClipboardContent.java

@@ -46,12 +46,40 @@ public class ClipboardContent {
 publicstaticfinalStringMIME_GIF = "image/gif";
 /// A local file reference (a file path / URI `String`, or a `String[]` for several files).
 publicstaticfinalStringMIME_FILE = "application/x-file-list";
+/// A newline separated list of URIs, the format desktop browsers and file managers use when
+/// a link or a file is dragged out of them.
+publicstaticfinalStringMIME_URI_LIST = "text/uri-list";
 
 privatefinalList<String> mimeTypes = newArrayList<String>();
 privatefinalList<Object> values = newArrayList<Object>();
 
 /// Adds or replaces a representation. Passing null removes the MIME type.
 publicClipboardContentsetData(StringmimeType, Objectvalue) {
+returnput(mimeType, value);
+ }
+
+/// Declares a representation that is only built if something reads it, which is how a drag
+/// offers a file it has not written yet or an image it has not encoded yet.
+///
+/// The provider is asked at most once and its answer is then cached, so
+/// `#getData(java.lang.String)` behaves exactly as it would for a value passed to
+/// `#setData(java.lang.String, java.lang.Object)`. It may run on a native clipboard or drag
+/// thread; see `ClipboardDataProvider`. Passing a null provider removes the MIME type.
+///
+/// #### Parameters
+///
+/// - `mimeType`: the MIME type this provider can produce
+///
+/// - `provider`: the provider, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetDataProvider(StringmimeType, ClipboardDataProviderprovider) {
+returnput(mimeType, provider == null ? null : newLazyValue(provider));
+ }
+
+privateClipboardContentput(StringmimeType, Objectvalue) {
 Stringnormalized = normalizeMimeType(mimeType);
 if (normalized.length() == 0) {
 thrownewIllegalArgumentException("MIME type must not be empty");
@@ -74,9 +102,41 @@ public ClipboardContent setData(String mimeType, Object value) {
  }
 
 /// Returns the representation for a MIME type, or null when it isn't available.
+///
+/// A representation registered through
+/// `#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)` is produced
+/// here, on the first call for that MIME type.
 publicObjectgetData(StringmimeType) {
 intindex = mimeTypes.indexOf(normalizeMimeType(mimeType));
-returnindex < 0 ? null : values.get(index);
+if (index < 0) {
+returnnull;
+ }
+Objectvalue = values.get(index);
+if (valueinstanceofLazyValue) {
+return ((LazyValue) value).resolve(mimeTypes.get(index));
+ }
+returnvalue;
+ }
+
+/// A provider plus the value it produced. The value is resolved once and remembered, so a
+/// target that asks twice -- as a drop does when it queries and then reads -- does not run
+/// the provider twice and does not, for instance, write the promised file twice.
+privatestaticfinalclassLazyValue {
+privatefinalClipboardDataProviderprovider;
+privateObjectresolved;
+privatebooleandone;
+
+LazyValue(ClipboardDataProviderprovider) {
+this.provider = provider;
+ }
+
+synchronizedObjectresolve(StringmimeType) {
+if (!done) {
+done = true;
+resolved = provider.getClipboardData(mimeType);
+ }
+returnresolved;
+ }
  }
 
 /// Returns the binary (`byte[]`) representation for a MIME type -- e.g. the raw bytes of an image
@@ -102,6 +162,43 @@ public String[] getMimeTypes() {
 returnmimeTypes.toArray(newString[mimeTypes.size()]);
  }
 
+/// Sets the `#MIME_FILE` representation from a list of file paths or `file:` URIs.
+///
+/// Ports differ on whether a single file is carried as a `String` or a one element
+/// `String[]`; this writes the form the rest of the framework expects, and
+/// `#getFiles()` reads either.
+///
+/// #### Parameters
+///
+/// - `paths`: the file paths, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetFiles(String[] paths) {
+if (paths == null || paths.length == 0) {
+returnsetData(MIME_FILE, null);
+ }
+if (paths.length == 1) {
+returnsetData(MIME_FILE, paths[0]);
+ }
+returnsetData(MIME_FILE, paths.clone());
+ }
+
+/// Returns the `#MIME_FILE` representation as a path array regardless of whether the
+/// producer stored one `String` or a `String[]`, or null when no files are available.
+publicString[] getFiles() {
+Objectvalue = getData(MIME_FILE);
+if (valueinstanceofString[]) {
+String[] paths = (String[]) value;
+returnpaths.length == 0 ? null : paths.clone();
+ }
+if (valueinstanceofString && ((String) value).length() > 0) {
+returnnewString[] { (String) value };
+ }
+returnnull;
+ }
+
 /// Returns the first available MIME type from the caller's preference list, or null.
 publicStringfindPreferredMimeType(String[] preferredMimeTypes) {
 if (preferredMimeTypes == null) {

CodenameOne/src/com/codename1/ui/ClipboardDataProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+
+package com.codename1.ui;
+
+/// Produces a clipboard or drag-and-drop representation on demand, so a payload that is
+/// expensive to build is only built if something actually asks for it.
+///
+/// This is what makes "drag a file out of the application" workable. A drag that offers
+/// `ClipboardContent#MIME_FILE` has to name the file when the drag *starts*, but the drop may
+/// never happen -- the user may let go over nothing -- and the target may prefer a different
+/// representation entirely. Registering a provider with
+/// `ClipboardContent#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)`
+/// declares that the representation is available without paying for it up front; the bytes are
+/// written, or the temporary file created, at the moment the receiving application reads that
+/// MIME type.
+///
+/// A provider is invoked at most once per `ClipboardContent` and MIME type -- the result is
+/// cached -- and it may be invoked from a native drag or clipboard thread rather than the event
+/// dispatch thread, so it must not touch the user interface.
+///
+/// #### When it actually runs
+///
+/// On the desktop and on iOS the provider runs when a receiver reads that representation, so a
+/// drag the user abandons costs nothing. Android is the exception: `startDragAndDrop` takes a
+/// complete clip, and a clip carries text or a reference to a file that already exists, so
+/// every provider runs as the drag begins. A drag out of an iOS application resolves its *file
+/// list* at the same moment for a related reason -- the system needs the number of items the
+/// drag carries, and for a file drag that is the number of files.
+///
+/// So a provider should be cheap enough to run once per drag, and must not assume it will only
+/// run when its data is wanted.
+public interface ClipboardDataProvider {
+ /// Produces the value for one representation.
+ ///
+ /// #### Parameters
+ ///
+ /// - `mimeType`: the MIME type being requested, always one this provider was registered for
+ ///
+ /// #### Returns
+ ///
+ /// the value, normally a `String`, a `String[]` of file paths or a `byte[]`, or null when
+ /// the representation turned out to be unavailable
+ Object getClipboardData(String mimeType);
+}

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -80,6 +80,7 @@
 importcom.codename1.ui.CN;
 importcom.codename1.ui.Command;
 importcom.codename1.ui.ClipboardContent;
+importcom.codename1.ui.NativeDragOperation;
 importcom.codename1.ui.Component;
 importcom.codename1.ui.Container;
 importcom.codename1.ui.Dialog;
@@ -5566,6 +5567,117 @@ public void installNativeTheme() {
 thrownewRuntimeException();
  }
 
+// ------------------------------------------------------------------------------------
+// Native (operating system) drag and drop. The payload is a ClipboardContent, the same one
+// copyToClipboard publishes, because a drag is a copy the user aims with the pointer.
+//
+// A port implements the outbound half here and calls
+// com.codename1.ui.NativeDragAndDrop for the inbound half.
+// ------------------------------------------------------------------------------------
+
+/// Returns true when this platform can hand a drag to the operating system. False here
+/// leaves the framework with only its lightweight in-form drag and drop, which is what
+/// every port had before.
+///
+/// #### Returns
+///
+/// true when native drag and drop is available
+publicbooleanisNativeDragAndDropSupported() {
+returnfalse;
+ }
+
+/// Returns true when a drag started in this application can be dropped outside it -- on the
+/// desktop, in a file manager, or in another application's window. Ports that can route a
+/// drag between their own components but not out of the application return false while
+/// still returning true from `#isNativeDragAndDropSupported()`.
+///
+/// #### Returns
+///
+/// true when a drag can leave the application
+publicbooleanisNativeDragOutsideApplicationSupported() {
+returnisNativeDragAndDropSupported();
+ }
+
+/// Hands the port the drag that would start if the press currently down turns into a drag.
+///
+/// Ports whose platform owns the gesture -- where the operating system's own recognizer
+/// decides a drag has begun and then asks what is being dragged -- answer from what they
+/// were given here. Ports that start the session themselves can ignore this and use
+/// `#startNativeDrag(com.codename1.ui.NativeDragOperation)`.
+///
+/// Invoked on the event dispatch thread, once per press. A press that produces no drag is
+/// followed by `#cancelNativeDrag()`.
+///
+/// #### Parameters
+///
+/// - `op`: the drag that is now possible
+publicvoidprepareNativeDrag(NativeDragOperationop) {
+ }
+
+/// Starts a native drag session now, because the pointer has moved far enough to be a drag.
+/// Invoked on the event dispatch thread while the pointer is still down.
+///
+/// A port that starts the session must eventually report the outcome through
+/// `com.codename1.ui.NativeDragAndDrop#dragCompleted(int)`, or a source that offered a move
+/// never learns whether to delete its copy.
+///
+/// #### Parameters
+///
+/// - `op`: what is being dragged
+///
+/// #### Returns
+///
+/// true when the operating system took the drag
+publicbooleanstartNativeDrag(NativeDragOperationop) {
+returnfalse;
+ }
+
+/// Discards whatever `#prepareNativeDrag(com.codename1.ui.NativeDragOperation)` staged,
+/// because the press turned out to be a click.
+publicvoidcancelNativeDrag() {
+ }
+
+/// Notifies the port that the application has a component that can be dragged through the
+/// operating system.
+///
+/// A platform whose drag gesture is its own -- UIKit's is -- recognizes that gesture with a
+/// recognizer installed on the surface, and installing one changes how every touch on that
+/// surface is delivered. Doing it unconditionally would alter touch handling for every
+/// application, including the overwhelming majority that never drags anything; a port that
+/// needs a recognizer therefore installs it here, the first time an application says it
+/// wants one.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDragSourceRegistered() {
+ }
+
+/// Notifies the port that the application has a component that accepts drops from the
+/// operating system.
+///
+/// The counterpart of `#nativeDragSourceRegistered()`, for the same reason: a port attaches
+/// whatever the platform needs in order to receive drops only for applications that asked
+/// to receive them, so an application that never does keeps exactly the input handling it
+/// had.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDropTargetRegistered() {
+ }
+
+/// True when the port needs the drag image at the moment the operation is staged rather
+/// than when the drag begins.
+///
+/// A port that starts the session itself renders the image then, which costs nothing for a
+/// press that turns out to be a click. A port whose platform owns the drag gesture is asked
+/// for the preview from inside that platform's own callback, which is not a moment at which
+/// a component can be rendered, so it has to have the image already.
+///
+/// #### Returns
+///
+/// true to render the drag image on every press over a native drag source
+publicbooleanisNativeDragImageNeededOnPrepare() {
+returnfalse;
+ }
+
 /// Performs a clipboard copy operation, if the native clipboard is supported by the implementation it would be used
 ///
 /// #### Parameters

CodenameOne/src/com/codename1/ui/ClipboardContent.java

@@ -46,12 +46,40 @@ public class ClipboardContent {
 publicstaticfinalStringMIME_GIF = "image/gif";
 /// A local file reference (a file path / URI `String`, or a `String[]` for several files).
 publicstaticfinalStringMIME_FILE = "application/x-file-list";
+/// A newline separated list of URIs, the format desktop browsers and file managers use when
+/// a link or a file is dragged out of them.
+publicstaticfinalStringMIME_URI_LIST = "text/uri-list";
 
 privatefinalList<String> mimeTypes = newArrayList<String>();
 privatefinalList<Object> values = newArrayList<Object>();
 
 /// Adds or replaces a representation. Passing null removes the MIME type.
 publicClipboardContentsetData(StringmimeType, Objectvalue) {
+returnput(mimeType, value);
+ }
+
+/// Declares a representation that is only built if something reads it, which is how a drag
+/// offers a file it has not written yet or an image it has not encoded yet.
+///
+/// The provider is asked at most once and its answer is then cached, so
+/// `#getData(java.lang.String)` behaves exactly as it would for a value passed to
+/// `#setData(java.lang.String, java.lang.Object)`. It may run on a native clipboard or drag
+/// thread; see `ClipboardDataProvider`. Passing a null provider removes the MIME type.
+///
+/// #### Parameters
+///
+/// - `mimeType`: the MIME type this provider can produce
+///
+/// - `provider`: the provider, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetDataProvider(StringmimeType, ClipboardDataProviderprovider) {
+returnput(mimeType, provider == null ? null : newLazyValue(provider));
+ }
+
+privateClipboardContentput(StringmimeType, Objectvalue) {
 Stringnormalized = normalizeMimeType(mimeType);
 if (normalized.length() == 0) {
 thrownewIllegalArgumentException("MIME type must not be empty");
@@ -74,9 +102,41 @@ public ClipboardContent setData(String mimeType, Object value) {
  }
 
 /// Returns the representation for a MIME type, or null when it isn't available.
+///
+/// A representation registered through
+/// `#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)` is produced
+/// here, on the first call for that MIME type.
 publicObjectgetData(StringmimeType) {
 intindex = mimeTypes.indexOf(normalizeMimeType(mimeType));
-returnindex < 0 ? null : values.get(index);
+if (index < 0) {
+returnnull;
+ }
+Objectvalue = values.get(index);
+if (valueinstanceofLazyValue) {
+return ((LazyValue) value).resolve(mimeTypes.get(index));
+ }
+returnvalue;
+ }
+
+/// A provider plus the value it produced. The value is resolved once and remembered, so a
+/// target that asks twice -- as a drop does when it queries and then reads -- does not run
+/// the provider twice and does not, for instance, write the promised file twice.
+privatestaticfinalclassLazyValue {
+privatefinalClipboardDataProviderprovider;
+privateObjectresolved;
+privatebooleandone;
+
+LazyValue(ClipboardDataProviderprovider) {
+this.provider = provider;
+ }
+
+synchronizedObjectresolve(StringmimeType) {
+if (!done) {
+done = true;
+resolved = provider.getClipboardData(mimeType);
+ }
+returnresolved;
+ }
  }
 
 /// Returns the binary (`byte[]`) representation for a MIME type -- e.g. the raw bytes of an image
@@ -102,6 +162,43 @@ public String[] getMimeTypes() {
 returnmimeTypes.toArray(newString[mimeTypes.size()]);
  }
 
+/// Sets the `#MIME_FILE` representation from a list of file paths or `file:` URIs.
+///
+/// Ports differ on whether a single file is carried as a `String` or a one element
+/// `String[]`; this writes the form the rest of the framework expects, and
+/// `#getFiles()` reads either.
+///
+/// #### Parameters
+///
+/// - `paths`: the file paths, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetFiles(String[] paths) {
+if (paths == null || paths.length == 0) {
+returnsetData(MIME_FILE, null);
+ }
+if (paths.length == 1) {
+returnsetData(MIME_FILE, paths[0]);
+ }
+returnsetData(MIME_FILE, paths.clone());
+ }
+
+/// Returns the `#MIME_FILE` representation as a path array regardless of whether the
+/// producer stored one `String` or a `String[]`, or null when no files are available.
+publicString[] getFiles() {
+Objectvalue = getData(MIME_FILE);
+if (valueinstanceofString[]) {
+String[] paths = (String[]) value;
+returnpaths.length == 0 ? null : paths.clone();
+ }
+if (valueinstanceofString && ((String) value).length() > 0) {
+returnnewString[] { (String) value };
+ }
+returnnull;
+ }
+
 /// Returns the first available MIME type from the caller's preference list, or null.
 publicStringfindPreferredMimeType(String[] preferredMimeTypes) {
 if (preferredMimeTypes == null) {

CodenameOne/src/com/codename1/ui/ClipboardDataProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+
+package com.codename1.ui;
+
+/// Produces a clipboard or drag-and-drop representation on demand, so a payload that is
+/// expensive to build is only built if something actually asks for it.
+///
+/// This is what makes "drag a file out of the application" workable. A drag that offers
+/// `ClipboardContent#MIME_FILE` has to name the file when the drag *starts*, but the drop may
+/// never happen -- the user may let go over nothing -- and the target may prefer a different
+/// representation entirely. Registering a provider with
+/// `ClipboardContent#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)`
+/// declares that the representation is available without paying for it up front; the bytes are
+/// written, or the temporary file created, at the moment the receiving application reads that
+/// MIME type.
+///
+/// A provider is invoked at most once per `ClipboardContent` and MIME type -- the result is
+/// cached -- and it may be invoked from a native drag or clipboard thread rather than the event
+/// dispatch thread, so it must not touch the user interface.
+///
+/// #### When it actually runs
+///
+/// On the desktop and on iOS the provider runs when a receiver reads that representation, so a
+/// drag the user abandons costs nothing. Android is the exception: `startDragAndDrop` takes a
+/// complete clip, and a clip carries text or a reference to a file that already exists, so
+/// every provider runs as the drag begins. A drag out of an iOS application resolves its *file
+/// list* at the same moment for a related reason -- the system needs the number of items the
+/// drag carries, and for a file drag that is the number of files.
+///
+/// So a provider should be cheap enough to run once per drag, and must not assume it will only
+/// run when its data is wanted.
+public interface ClipboardDataProvider {
+ /// Produces the value for one representation.
+ ///
+ /// #### Parameters
+ ///
+ /// - `mimeType`: the MIME type being requested, always one this provider was registered for
+ ///
+ /// #### Returns
+ ///
+ /// the value, normally a `String`, a `String[]` of file paths or a `byte[]`, or null when
+ /// the representation turned out to be unavailable
+ Object getClipboardData(String mimeType);
+}

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -80,6 +80,7 @@
 importcom.codename1.ui.CN;
 importcom.codename1.ui.Command;
 importcom.codename1.ui.ClipboardContent;
+importcom.codename1.ui.NativeDragOperation;
 importcom.codename1.ui.Component;
 importcom.codename1.ui.Container;
 importcom.codename1.ui.Dialog;
@@ -5566,6 +5567,117 @@ public void installNativeTheme() {
 thrownewRuntimeException();
  }
 
+// ------------------------------------------------------------------------------------
+// Native (operating system) drag and drop. The payload is a ClipboardContent, the same one
+// copyToClipboard publishes, because a drag is a copy the user aims with the pointer.
+//
+// A port implements the outbound half here and calls
+// com.codename1.ui.NativeDragAndDrop for the inbound half.
+// ------------------------------------------------------------------------------------
+
+/// Returns true when this platform can hand a drag to the operating system. False here
+/// leaves the framework with only its lightweight in-form drag and drop, which is what
+/// every port had before.
+///
+/// #### Returns
+///
+/// true when native drag and drop is available
+publicbooleanisNativeDragAndDropSupported() {
+returnfalse;
+ }
+
+/// Returns true when a drag started in this application can be dropped outside it -- on the
+/// desktop, in a file manager, or in another application's window. Ports that can route a
+/// drag between their own components but not out of the application return false while
+/// still returning true from `#isNativeDragAndDropSupported()`.
+///
+/// #### Returns
+///
+/// true when a drag can leave the application
+publicbooleanisNativeDragOutsideApplicationSupported() {
+returnisNativeDragAndDropSupported();
+ }
+
+/// Hands the port the drag that would start if the press currently down turns into a drag.
+///
+/// Ports whose platform owns the gesture -- where the operating system's own recognizer
+/// decides a drag has begun and then asks what is being dragged -- answer from what they
+/// were given here. Ports that start the session themselves can ignore this and use
+/// `#startNativeDrag(com.codename1.ui.NativeDragOperation)`.
+///
+/// Invoked on the event dispatch thread, once per press. A press that produces no drag is
+/// followed by `#cancelNativeDrag()`.
+///
+/// #### Parameters
+///
+/// - `op`: the drag that is now possible
+publicvoidprepareNativeDrag(NativeDragOperationop) {
+ }
+
+/// Starts a native drag session now, because the pointer has moved far enough to be a drag.
+/// Invoked on the event dispatch thread while the pointer is still down.
+///
+/// A port that starts the session must eventually report the outcome through
+/// `com.codename1.ui.NativeDragAndDrop#dragCompleted(int)`, or a source that offered a move
+/// never learns whether to delete its copy.
+///
+/// #### Parameters
+///
+/// - `op`: what is being dragged
+///
+/// #### Returns
+///
+/// true when the operating system took the drag
+publicbooleanstartNativeDrag(NativeDragOperationop) {
+returnfalse;
+ }
+
+/// Discards whatever `#prepareNativeDrag(com.codename1.ui.NativeDragOperation)` staged,
+/// because the press turned out to be a click.
+publicvoidcancelNativeDrag() {
+ }
+
+/// Notifies the port that the application has a component that can be dragged through the
+/// operating system.
+///
+/// A platform whose drag gesture is its own -- UIKit's is -- recognizes that gesture with a
+/// recognizer installed on the surface, and installing one changes how every touch on that
+/// surface is delivered. Doing it unconditionally would alter touch handling for every
+/// application, including the overwhelming majority that never drags anything; a port that
+/// needs a recognizer therefore installs it here, the first time an application says it
+/// wants one.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDragSourceRegistered() {
+ }
+
+/// Notifies the port that the application has a component that accepts drops from the
+/// operating system.
+///
+/// The counterpart of `#nativeDragSourceRegistered()`, for the same reason: a port attaches
+/// whatever the platform needs in order to receive drops only for applications that asked
+/// to receive them, so an application that never does keeps exactly the input handling it
+/// had.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDropTargetRegistered() {
+ }
+
+/// True when the port needs the drag image at the moment the operation is staged rather
+/// than when the drag begins.
+///
+/// A port that starts the session itself renders the image then, which costs nothing for a
+/// press that turns out to be a click. A port whose platform owns the drag gesture is asked
+/// for the preview from inside that platform's own callback, which is not a moment at which
+/// a component can be rendered, so it has to have the image already.
+///
+/// #### Returns
+///
+/// true to render the drag image on every press over a native drag source
+publicbooleanisNativeDragImageNeededOnPrepare() {
+returnfalse;
+ }
+
 /// Performs a clipboard copy operation, if the native clipboard is supported by the implementation it would be used
 ///
 /// #### Parameters

CodenameOne/src/com/codename1/ui/ClipboardContent.java

@@ -46,12 +46,40 @@ public class ClipboardContent {
 publicstaticfinalStringMIME_GIF = "image/gif";
 /// A local file reference (a file path / URI `String`, or a `String[]` for several files).
 publicstaticfinalStringMIME_FILE = "application/x-file-list";
+/// A newline separated list of URIs, the format desktop browsers and file managers use when
+/// a link or a file is dragged out of them.
+publicstaticfinalStringMIME_URI_LIST = "text/uri-list";
 
 privatefinalList<String> mimeTypes = newArrayList<String>();
 privatefinalList<Object> values = newArrayList<Object>();
 
 /// Adds or replaces a representation. Passing null removes the MIME type.
 publicClipboardContentsetData(StringmimeType, Objectvalue) {
+returnput(mimeType, value);
+ }
+
+/// Declares a representation that is only built if something reads it, which is how a drag
+/// offers a file it has not written yet or an image it has not encoded yet.
+///
+/// The provider is asked at most once and its answer is then cached, so
+/// `#getData(java.lang.String)` behaves exactly as it would for a value passed to
+/// `#setData(java.lang.String, java.lang.Object)`. It may run on a native clipboard or drag
+/// thread; see `ClipboardDataProvider`. Passing a null provider removes the MIME type.
+///
+/// #### Parameters
+///
+/// - `mimeType`: the MIME type this provider can produce
+///
+/// - `provider`: the provider, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetDataProvider(StringmimeType, ClipboardDataProviderprovider) {
+returnput(mimeType, provider == null ? null : newLazyValue(provider));
+ }
+
+privateClipboardContentput(StringmimeType, Objectvalue) {
 Stringnormalized = normalizeMimeType(mimeType);
 if (normalized.length() == 0) {
 thrownewIllegalArgumentException("MIME type must not be empty");
@@ -74,9 +102,41 @@ public ClipboardContent setData(String mimeType, Object value) {
  }
 
 /// Returns the representation for a MIME type, or null when it isn't available.
+///
+/// A representation registered through
+/// `#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)` is produced
+/// here, on the first call for that MIME type.
 publicObjectgetData(StringmimeType) {
 intindex = mimeTypes.indexOf(normalizeMimeType(mimeType));
-returnindex < 0 ? null : values.get(index);
+if (index < 0) {
+returnnull;
+ }
+Objectvalue = values.get(index);
+if (valueinstanceofLazyValue) {
+return ((LazyValue) value).resolve(mimeTypes.get(index));
+ }
+returnvalue;
+ }
+
+/// A provider plus the value it produced. The value is resolved once and remembered, so a
+/// target that asks twice -- as a drop does when it queries and then reads -- does not run
+/// the provider twice and does not, for instance, write the promised file twice.
+privatestaticfinalclassLazyValue {
+privatefinalClipboardDataProviderprovider;
+privateObjectresolved;
+privatebooleandone;
+
+LazyValue(ClipboardDataProviderprovider) {
+this.provider = provider;
+ }
+
+synchronizedObjectresolve(StringmimeType) {
+if (!done) {
+done = true;
+resolved = provider.getClipboardData(mimeType);
+ }
+returnresolved;
+ }
  }
 
 /// Returns the binary (`byte[]`) representation for a MIME type -- e.g. the raw bytes of an image
@@ -102,6 +162,43 @@ public String[] getMimeTypes() {
 returnmimeTypes.toArray(newString[mimeTypes.size()]);
  }
 
+/// Sets the `#MIME_FILE` representation from a list of file paths or `file:` URIs.
+///
+/// Ports differ on whether a single file is carried as a `String` or a one element
+/// `String[]`; this writes the form the rest of the framework expects, and
+/// `#getFiles()` reads either.
+///
+/// #### Parameters
+///
+/// - `paths`: the file paths, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetFiles(String[] paths) {
+if (paths == null || paths.length == 0) {
+returnsetData(MIME_FILE, null);
+ }
+if (paths.length == 1) {
+returnsetData(MIME_FILE, paths[0]);
+ }
+returnsetData(MIME_FILE, paths.clone());
+ }
+
+/// Returns the `#MIME_FILE` representation as a path array regardless of whether the
+/// producer stored one `String` or a `String[]`, or null when no files are available.
+publicString[] getFiles() {
+Objectvalue = getData(MIME_FILE);
+if (valueinstanceofString[]) {
+String[] paths = (String[]) value;
+returnpaths.length == 0 ? null : paths.clone();
+ }
+if (valueinstanceofString && ((String) value).length() > 0) {
+returnnewString[] { (String) value };
+ }
+returnnull;
+ }
+
 /// Returns the first available MIME type from the caller's preference list, or null.
 publicStringfindPreferredMimeType(String[] preferredMimeTypes) {
 if (preferredMimeTypes == null) {

CodenameOne/src/com/codename1/ui/ClipboardDataProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+
+package com.codename1.ui;
+
+/// Produces a clipboard or drag-and-drop representation on demand, so a payload that is
+/// expensive to build is only built if something actually asks for it.
+///
+/// This is what makes "drag a file out of the application" workable. A drag that offers
+/// `ClipboardContent#MIME_FILE` has to name the file when the drag *starts*, but the drop may
+/// never happen -- the user may let go over nothing -- and the target may prefer a different
+/// representation entirely. Registering a provider with
+/// `ClipboardContent#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)`
+/// declares that the representation is available without paying for it up front; the bytes are
+/// written, or the temporary file created, at the moment the receiving application reads that
+/// MIME type.
+///
+/// A provider is invoked at most once per `ClipboardContent` and MIME type -- the result is
+/// cached -- and it may be invoked from a native drag or clipboard thread rather than the event
+/// dispatch thread, so it must not touch the user interface.
+///
+/// #### When it actually runs
+///
+/// On the desktop and on iOS the provider runs when a receiver reads that representation, so a
+/// drag the user abandons costs nothing. Android is the exception: `startDragAndDrop` takes a
+/// complete clip, and a clip carries text or a reference to a file that already exists, so
+/// every provider runs as the drag begins. A drag out of an iOS application resolves its *file
+/// list* at the same moment for a related reason -- the system needs the number of items the
+/// drag carries, and for a file drag that is the number of files.
+///
+/// So a provider should be cheap enough to run once per drag, and must not assume it will only
+/// run when its data is wanted.
+public interface ClipboardDataProvider {
+ /// Produces the value for one representation.
+ ///
+ /// #### Parameters
+ ///
+ /// - `mimeType`: the MIME type being requested, always one this provider was registered for
+ ///
+ /// #### Returns
+ ///
+ /// the value, normally a `String`, a `String[]` of file paths or a `byte[]`, or null when
+ /// the representation turned out to be unavailable
+ Object getClipboardData(String mimeType);
+}

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -80,6 +80,7 @@
 importcom.codename1.ui.CN;
 importcom.codename1.ui.Command;
 importcom.codename1.ui.ClipboardContent;
+importcom.codename1.ui.NativeDragOperation;
 importcom.codename1.ui.Component;
 importcom.codename1.ui.Container;
 importcom.codename1.ui.Dialog;
@@ -5566,6 +5567,117 @@ public void installNativeTheme() {
 thrownewRuntimeException();
  }
 
+// ------------------------------------------------------------------------------------
+// Native (operating system) drag and drop. The payload is a ClipboardContent, the same one
+// copyToClipboard publishes, because a drag is a copy the user aims with the pointer.
+//
+// A port implements the outbound half here and calls
+// com.codename1.ui.NativeDragAndDrop for the inbound half.
+// ------------------------------------------------------------------------------------
+
+/// Returns true when this platform can hand a drag to the operating system. False here
+/// leaves the framework with only its lightweight in-form drag and drop, which is what
+/// every port had before.
+///
+/// #### Returns
+///
+/// true when native drag and drop is available
+publicbooleanisNativeDragAndDropSupported() {
+returnfalse;
+ }
+
+/// Returns true when a drag started in this application can be dropped outside it -- on the
+/// desktop, in a file manager, or in another application's window. Ports that can route a
+/// drag between their own components but not out of the application return false while
+/// still returning true from `#isNativeDragAndDropSupported()`.
+///
+/// #### Returns
+///
+/// true when a drag can leave the application
+publicbooleanisNativeDragOutsideApplicationSupported() {
+returnisNativeDragAndDropSupported();
+ }
+
+/// Hands the port the drag that would start if the press currently down turns into a drag.
+///
+/// Ports whose platform owns the gesture -- where the operating system's own recognizer
+/// decides a drag has begun and then asks what is being dragged -- answer from what they
+/// were given here. Ports that start the session themselves can ignore this and use
+/// `#startNativeDrag(com.codename1.ui.NativeDragOperation)`.
+///
+/// Invoked on the event dispatch thread, once per press. A press that produces no drag is
+/// followed by `#cancelNativeDrag()`.
+///
+/// #### Parameters
+///
+/// - `op`: the drag that is now possible
+publicvoidprepareNativeDrag(NativeDragOperationop) {
+ }
+
+/// Starts a native drag session now, because the pointer has moved far enough to be a drag.
+/// Invoked on the event dispatch thread while the pointer is still down.
+///
+/// A port that starts the session must eventually report the outcome through
+/// `com.codename1.ui.NativeDragAndDrop#dragCompleted(int)`, or a source that offered a move
+/// never learns whether to delete its copy.
+///
+/// #### Parameters
+///
+/// - `op`: what is being dragged
+///
+/// #### Returns
+///
+/// true when the operating system took the drag
+publicbooleanstartNativeDrag(NativeDragOperationop) {
+returnfalse;
+ }
+
+/// Discards whatever `#prepareNativeDrag(com.codename1.ui.NativeDragOperation)` staged,
+/// because the press turned out to be a click.
+publicvoidcancelNativeDrag() {
+ }
+
+/// Notifies the port that the application has a component that can be dragged through the
+/// operating system.
+///
+/// A platform whose drag gesture is its own -- UIKit's is -- recognizes that gesture with a
+/// recognizer installed on the surface, and installing one changes how every touch on that
+/// surface is delivered. Doing it unconditionally would alter touch handling for every
+/// application, including the overwhelming majority that never drags anything; a port that
+/// needs a recognizer therefore installs it here, the first time an application says it
+/// wants one.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDragSourceRegistered() {
+ }
+
+/// Notifies the port that the application has a component that accepts drops from the
+/// operating system.
+///
+/// The counterpart of `#nativeDragSourceRegistered()`, for the same reason: a port attaches
+/// whatever the platform needs in order to receive drops only for applications that asked
+/// to receive them, so an application that never does keeps exactly the input handling it
+/// had.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDropTargetRegistered() {
+ }
+
+/// True when the port needs the drag image at the moment the operation is staged rather
+/// than when the drag begins.
+///
+/// A port that starts the session itself renders the image then, which costs nothing for a
+/// press that turns out to be a click. A port whose platform owns the drag gesture is asked
+/// for the preview from inside that platform's own callback, which is not a moment at which
+/// a component can be rendered, so it has to have the image already.
+///
+/// #### Returns
+///
+/// true to render the drag image on every press over a native drag source
+publicbooleanisNativeDragImageNeededOnPrepare() {
+returnfalse;
+ }
+
 /// Performs a clipboard copy operation, if the native clipboard is supported by the implementation it would be used
 ///
 /// #### Parameters

CodenameOne/src/com/codename1/ui/ClipboardContent.java

@@ -46,12 +46,40 @@ public class ClipboardContent {
 publicstaticfinalStringMIME_GIF = "image/gif";
 /// A local file reference (a file path / URI `String`, or a `String[]` for several files).
 publicstaticfinalStringMIME_FILE = "application/x-file-list";
+/// A newline separated list of URIs, the format desktop browsers and file managers use when
+/// a link or a file is dragged out of them.
+publicstaticfinalStringMIME_URI_LIST = "text/uri-list";
 
 privatefinalList<String> mimeTypes = newArrayList<String>();
 privatefinalList<Object> values = newArrayList<Object>();
 
 /// Adds or replaces a representation. Passing null removes the MIME type.
 publicClipboardContentsetData(StringmimeType, Objectvalue) {
+returnput(mimeType, value);
+ }
+
+/// Declares a representation that is only built if something reads it, which is how a drag
+/// offers a file it has not written yet or an image it has not encoded yet.
+///
+/// The provider is asked at most once and its answer is then cached, so
+/// `#getData(java.lang.String)` behaves exactly as it would for a value passed to
+/// `#setData(java.lang.String, java.lang.Object)`. It may run on a native clipboard or drag
+/// thread; see `ClipboardDataProvider`. Passing a null provider removes the MIME type.
+///
+/// #### Parameters
+///
+/// - `mimeType`: the MIME type this provider can produce
+///
+/// - `provider`: the provider, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetDataProvider(StringmimeType, ClipboardDataProviderprovider) {
+returnput(mimeType, provider == null ? null : newLazyValue(provider));
+ }
+
+privateClipboardContentput(StringmimeType, Objectvalue) {
 Stringnormalized = normalizeMimeType(mimeType);
 if (normalized.length() == 0) {
 thrownewIllegalArgumentException("MIME type must not be empty");
@@ -74,9 +102,41 @@ public ClipboardContent setData(String mimeType, Object value) {
  }
 
 /// Returns the representation for a MIME type, or null when it isn't available.
+///
+/// A representation registered through
+/// `#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)` is produced
+/// here, on the first call for that MIME type.
 publicObjectgetData(StringmimeType) {
 intindex = mimeTypes.indexOf(normalizeMimeType(mimeType));
-returnindex < 0 ? null : values.get(index);
+if (index < 0) {
+returnnull;
+ }
+Objectvalue = values.get(index);
+if (valueinstanceofLazyValue) {
+return ((LazyValue) value).resolve(mimeTypes.get(index));
+ }
+returnvalue;
+ }
+
+/// A provider plus the value it produced. The value is resolved once and remembered, so a
+/// target that asks twice -- as a drop does when it queries and then reads -- does not run
+/// the provider twice and does not, for instance, write the promised file twice.
+privatestaticfinalclassLazyValue {
+privatefinalClipboardDataProviderprovider;
+privateObjectresolved;
+privatebooleandone;
+
+LazyValue(ClipboardDataProviderprovider) {
+this.provider = provider;
+ }
+
+synchronizedObjectresolve(StringmimeType) {
+if (!done) {
+done = true;
+resolved = provider.getClipboardData(mimeType);
+ }
+returnresolved;
+ }
  }
 
 /// Returns the binary (`byte[]`) representation for a MIME type -- e.g. the raw bytes of an image
@@ -102,6 +162,43 @@ public String[] getMimeTypes() {
 returnmimeTypes.toArray(newString[mimeTypes.size()]);
  }
 
+/// Sets the `#MIME_FILE` representation from a list of file paths or `file:` URIs.
+///
+/// Ports differ on whether a single file is carried as a `String` or a one element
+/// `String[]`; this writes the form the rest of the framework expects, and
+/// `#getFiles()` reads either.
+///
+/// #### Parameters
+///
+/// - `paths`: the file paths, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetFiles(String[] paths) {
+if (paths == null || paths.length == 0) {
+returnsetData(MIME_FILE, null);
+ }
+if (paths.length == 1) {
+returnsetData(MIME_FILE, paths[0]);
+ }
+returnsetData(MIME_FILE, paths.clone());
+ }
+
+/// Returns the `#MIME_FILE` representation as a path array regardless of whether the
+/// producer stored one `String` or a `String[]`, or null when no files are available.
+publicString[] getFiles() {
+Objectvalue = getData(MIME_FILE);
+if (valueinstanceofString[]) {
+String[] paths = (String[]) value;
+returnpaths.length == 0 ? null : paths.clone();
+ }
+if (valueinstanceofString && ((String) value).length() > 0) {
+returnnewString[] { (String) value };
+ }
+returnnull;
+ }
+
 /// Returns the first available MIME type from the caller's preference list, or null.
 publicStringfindPreferredMimeType(String[] preferredMimeTypes) {
 if (preferredMimeTypes == null) {

CodenameOne/src/com/codename1/ui/ClipboardDataProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+
+package com.codename1.ui;
+
+/// Produces a clipboard or drag-and-drop representation on demand, so a payload that is
+/// expensive to build is only built if something actually asks for it.
+///
+/// This is what makes "drag a file out of the application" workable. A drag that offers
+/// `ClipboardContent#MIME_FILE` has to name the file when the drag *starts*, but the drop may
+/// never happen -- the user may let go over nothing -- and the target may prefer a different
+/// representation entirely. Registering a provider with
+/// `ClipboardContent#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)`
+/// declares that the representation is available without paying for it up front; the bytes are
+/// written, or the temporary file created, at the moment the receiving application reads that
+/// MIME type.
+///
+/// A provider is invoked at most once per `ClipboardContent` and MIME type -- the result is
+/// cached -- and it may be invoked from a native drag or clipboard thread rather than the event
+/// dispatch thread, so it must not touch the user interface.
+///
+/// #### When it actually runs
+///
+/// On the desktop and on iOS the provider runs when a receiver reads that representation, so a
+/// drag the user abandons costs nothing. Android is the exception: `startDragAndDrop` takes a
+/// complete clip, and a clip carries text or a reference to a file that already exists, so
+/// every provider runs as the drag begins. A drag out of an iOS application resolves its *file
+/// list* at the same moment for a related reason -- the system needs the number of items the
+/// drag carries, and for a file drag that is the number of files.
+///
+/// So a provider should be cheap enough to run once per drag, and must not assume it will only
+/// run when its data is wanted.
+public interface ClipboardDataProvider {
+ /// Produces the value for one representation.
+ ///
+ /// #### Parameters
+ ///
+ /// - `mimeType`: the MIME type being requested, always one this provider was registered for
+ ///
+ /// #### Returns
+ ///
+ /// the value, normally a `String`, a `String[]` of file paths or a `byte[]`, or null when
+ /// the representation turned out to be unavailable
+ Object getClipboardData(String mimeType);
+}

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -80,6 +80,7 @@
 importcom.codename1.ui.CN;
 importcom.codename1.ui.Command;
 importcom.codename1.ui.ClipboardContent;
+importcom.codename1.ui.NativeDragOperation;
 importcom.codename1.ui.Component;
 importcom.codename1.ui.Container;
 importcom.codename1.ui.Dialog;
@@ -5566,6 +5567,117 @@ public void installNativeTheme() {
 thrownewRuntimeException();
  }
 
+// ------------------------------------------------------------------------------------
+// Native (operating system) drag and drop. The payload is a ClipboardContent, the same one
+// copyToClipboard publishes, because a drag is a copy the user aims with the pointer.
+//
+// A port implements the outbound half here and calls
+// com.codename1.ui.NativeDragAndDrop for the inbound half.
+// ------------------------------------------------------------------------------------
+
+/// Returns true when this platform can hand a drag to the operating system. False here
+/// leaves the framework with only its lightweight in-form drag and drop, which is what
+/// every port had before.
+///
+/// #### Returns
+///
+/// true when native drag and drop is available
+publicbooleanisNativeDragAndDropSupported() {
+returnfalse;
+ }
+
+/// Returns true when a drag started in this application can be dropped outside it -- on the
+/// desktop, in a file manager, or in another application's window. Ports that can route a
+/// drag between their own components but not out of the application return false while
+/// still returning true from `#isNativeDragAndDropSupported()`.
+///
+/// #### Returns
+///
+/// true when a drag can leave the application
+publicbooleanisNativeDragOutsideApplicationSupported() {
+returnisNativeDragAndDropSupported();
+ }
+
+/// Hands the port the drag that would start if the press currently down turns into a drag.
+///
+/// Ports whose platform owns the gesture -- where the operating system's own recognizer
+/// decides a drag has begun and then asks what is being dragged -- answer from what they
+/// were given here. Ports that start the session themselves can ignore this and use
+/// `#startNativeDrag(com.codename1.ui.NativeDragOperation)`.
+///
+/// Invoked on the event dispatch thread, once per press. A press that produces no drag is
+/// followed by `#cancelNativeDrag()`.
+///
+/// #### Parameters
+///
+/// - `op`: the drag that is now possible
+publicvoidprepareNativeDrag(NativeDragOperationop) {
+ }
+
+/// Starts a native drag session now, because the pointer has moved far enough to be a drag.
+/// Invoked on the event dispatch thread while the pointer is still down.
+///
+/// A port that starts the session must eventually report the outcome through
+/// `com.codename1.ui.NativeDragAndDrop#dragCompleted(int)`, or a source that offered a move
+/// never learns whether to delete its copy.
+///
+/// #### Parameters
+///
+/// - `op`: what is being dragged
+///
+/// #### Returns
+///
+/// true when the operating system took the drag
+publicbooleanstartNativeDrag(NativeDragOperationop) {
+returnfalse;
+ }
+
+/// Discards whatever `#prepareNativeDrag(com.codename1.ui.NativeDragOperation)` staged,
+/// because the press turned out to be a click.
+publicvoidcancelNativeDrag() {
+ }
+
+/// Notifies the port that the application has a component that can be dragged through the
+/// operating system.
+///
+/// A platform whose drag gesture is its own -- UIKit's is -- recognizes that gesture with a
+/// recognizer installed on the surface, and installing one changes how every touch on that
+/// surface is delivered. Doing it unconditionally would alter touch handling for every
+/// application, including the overwhelming majority that never drags anything; a port that
+/// needs a recognizer therefore installs it here, the first time an application says it
+/// wants one.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDragSourceRegistered() {
+ }
+
+/// Notifies the port that the application has a component that accepts drops from the
+/// operating system.
+///
+/// The counterpart of `#nativeDragSourceRegistered()`, for the same reason: a port attaches
+/// whatever the platform needs in order to receive drops only for applications that asked
+/// to receive them, so an application that never does keeps exactly the input handling it
+/// had.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDropTargetRegistered() {
+ }
+
+/// True when the port needs the drag image at the moment the operation is staged rather
+/// than when the drag begins.
+///
+/// A port that starts the session itself renders the image then, which costs nothing for a
+/// press that turns out to be a click. A port whose platform owns the drag gesture is asked
+/// for the preview from inside that platform's own callback, which is not a moment at which
+/// a component can be rendered, so it has to have the image already.
+///
+/// #### Returns
+///
+/// true to render the drag image on every press over a native drag source
+publicbooleanisNativeDragImageNeededOnPrepare() {
+returnfalse;
+ }
+
 /// Performs a clipboard copy operation, if the native clipboard is supported by the implementation it would be used
 ///
 /// #### Parameters

CodenameOne/src/com/codename1/ui/ClipboardContent.java

@@ -46,12 +46,40 @@ public class ClipboardContent {
 publicstaticfinalStringMIME_GIF = "image/gif";
 /// A local file reference (a file path / URI `String`, or a `String[]` for several files).
 publicstaticfinalStringMIME_FILE = "application/x-file-list";
+/// A newline separated list of URIs, the format desktop browsers and file managers use when
+/// a link or a file is dragged out of them.
+publicstaticfinalStringMIME_URI_LIST = "text/uri-list";
 
 privatefinalList<String> mimeTypes = newArrayList<String>();
 privatefinalList<Object> values = newArrayList<Object>();
 
 /// Adds or replaces a representation. Passing null removes the MIME type.
 publicClipboardContentsetData(StringmimeType, Objectvalue) {
+returnput(mimeType, value);
+ }
+
+/// Declares a representation that is only built if something reads it, which is how a drag
+/// offers a file it has not written yet or an image it has not encoded yet.
+///
+/// The provider is asked at most once and its answer is then cached, so
+/// `#getData(java.lang.String)` behaves exactly as it would for a value passed to
+/// `#setData(java.lang.String, java.lang.Object)`. It may run on a native clipboard or drag
+/// thread; see `ClipboardDataProvider`. Passing a null provider removes the MIME type.
+///
+/// #### Parameters
+///
+/// - `mimeType`: the MIME type this provider can produce
+///
+/// - `provider`: the provider, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetDataProvider(StringmimeType, ClipboardDataProviderprovider) {
+returnput(mimeType, provider == null ? null : newLazyValue(provider));
+ }
+
+privateClipboardContentput(StringmimeType, Objectvalue) {
 Stringnormalized = normalizeMimeType(mimeType);
 if (normalized.length() == 0) {
 thrownewIllegalArgumentException("MIME type must not be empty");
@@ -74,9 +102,41 @@ public ClipboardContent setData(String mimeType, Object value) {
  }
 
 /// Returns the representation for a MIME type, or null when it isn't available.
+///
+/// A representation registered through
+/// `#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)` is produced
+/// here, on the first call for that MIME type.
 publicObjectgetData(StringmimeType) {
 intindex = mimeTypes.indexOf(normalizeMimeType(mimeType));
-returnindex < 0 ? null : values.get(index);
+if (index < 0) {
+returnnull;
+ }
+Objectvalue = values.get(index);
+if (valueinstanceofLazyValue) {
+return ((LazyValue) value).resolve(mimeTypes.get(index));
+ }
+returnvalue;
+ }
+
+/// A provider plus the value it produced. The value is resolved once and remembered, so a
+/// target that asks twice -- as a drop does when it queries and then reads -- does not run
+/// the provider twice and does not, for instance, write the promised file twice.
+privatestaticfinalclassLazyValue {
+privatefinalClipboardDataProviderprovider;
+privateObjectresolved;
+privatebooleandone;
+
+LazyValue(ClipboardDataProviderprovider) {
+this.provider = provider;
+ }
+
+synchronizedObjectresolve(StringmimeType) {
+if (!done) {
+done = true;
+resolved = provider.getClipboardData(mimeType);
+ }
+returnresolved;
+ }
  }
 
 /// Returns the binary (`byte[]`) representation for a MIME type -- e.g. the raw bytes of an image
@@ -102,6 +162,43 @@ public String[] getMimeTypes() {
 returnmimeTypes.toArray(newString[mimeTypes.size()]);
  }
 
+/// Sets the `#MIME_FILE` representation from a list of file paths or `file:` URIs.
+///
+/// Ports differ on whether a single file is carried as a `String` or a one element
+/// `String[]`; this writes the form the rest of the framework expects, and
+/// `#getFiles()` reads either.
+///
+/// #### Parameters
+///
+/// - `paths`: the file paths, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetFiles(String[] paths) {
+if (paths == null || paths.length == 0) {
+returnsetData(MIME_FILE, null);
+ }
+if (paths.length == 1) {
+returnsetData(MIME_FILE, paths[0]);
+ }
+returnsetData(MIME_FILE, paths.clone());
+ }
+
+/// Returns the `#MIME_FILE` representation as a path array regardless of whether the
+/// producer stored one `String` or a `String[]`, or null when no files are available.
+publicString[] getFiles() {
+Objectvalue = getData(MIME_FILE);
+if (valueinstanceofString[]) {
+String[] paths = (String[]) value;
+returnpaths.length == 0 ? null : paths.clone();
+ }
+if (valueinstanceofString && ((String) value).length() > 0) {
+returnnewString[] { (String) value };
+ }
+returnnull;
+ }
+
 /// Returns the first available MIME type from the caller's preference list, or null.
 publicStringfindPreferredMimeType(String[] preferredMimeTypes) {
 if (preferredMimeTypes == null) {

CodenameOne/src/com/codename1/ui/ClipboardDataProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+
+package com.codename1.ui;
+
+/// Produces a clipboard or drag-and-drop representation on demand, so a payload that is
+/// expensive to build is only built if something actually asks for it.
+///
+/// This is what makes "drag a file out of the application" workable. A drag that offers
+/// `ClipboardContent#MIME_FILE` has to name the file when the drag *starts*, but the drop may
+/// never happen -- the user may let go over nothing -- and the target may prefer a different
+/// representation entirely. Registering a provider with
+/// `ClipboardContent#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)`
+/// declares that the representation is available without paying for it up front; the bytes are
+/// written, or the temporary file created, at the moment the receiving application reads that
+/// MIME type.
+///
+/// A provider is invoked at most once per `ClipboardContent` and MIME type -- the result is
+/// cached -- and it may be invoked from a native drag or clipboard thread rather than the event
+/// dispatch thread, so it must not touch the user interface.
+///
+/// #### When it actually runs
+///
+/// On the desktop and on iOS the provider runs when a receiver reads that representation, so a
+/// drag the user abandons costs nothing. Android is the exception: `startDragAndDrop` takes a
+/// complete clip, and a clip carries text or a reference to a file that already exists, so
+/// every provider runs as the drag begins. A drag out of an iOS application resolves its *file
+/// list* at the same moment for a related reason -- the system needs the number of items the
+/// drag carries, and for a file drag that is the number of files.
+///
+/// So a provider should be cheap enough to run once per drag, and must not assume it will only
+/// run when its data is wanted.
+public interface ClipboardDataProvider {
+ /// Produces the value for one representation.
+ ///
+ /// #### Parameters
+ ///
+ /// - `mimeType`: the MIME type being requested, always one this provider was registered for
+ ///
+ /// #### Returns
+ ///
+ /// the value, normally a `String`, a `String[]` of file paths or a `byte[]`, or null when
+ /// the representation turned out to be unavailable
+ Object getClipboardData(String mimeType);
+}

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -80,6 +80,7 @@
 importcom.codename1.ui.CN;
 importcom.codename1.ui.Command;
 importcom.codename1.ui.ClipboardContent;
+importcom.codename1.ui.NativeDragOperation;
 importcom.codename1.ui.Component;
 importcom.codename1.ui.Container;
 importcom.codename1.ui.Dialog;
@@ -5566,6 +5567,117 @@ public void installNativeTheme() {
 thrownewRuntimeException();
  }
 
+// ------------------------------------------------------------------------------------
+// Native (operating system) drag and drop. The payload is a ClipboardContent, the same one
+// copyToClipboard publishes, because a drag is a copy the user aims with the pointer.
+//
+// A port implements the outbound half here and calls
+// com.codename1.ui.NativeDragAndDrop for the inbound half.
+// ------------------------------------------------------------------------------------
+
+/// Returns true when this platform can hand a drag to the operating system. False here
+/// leaves the framework with only its lightweight in-form drag and drop, which is what
+/// every port had before.
+///
+/// #### Returns
+///
+/// true when native drag and drop is available
+publicbooleanisNativeDragAndDropSupported() {
+returnfalse;
+ }
+
+/// Returns true when a drag started in this application can be dropped outside it -- on the
+/// desktop, in a file manager, or in another application's window. Ports that can route a
+/// drag between their own components but not out of the application return false while
+/// still returning true from `#isNativeDragAndDropSupported()`.
+///
+/// #### Returns
+///
+/// true when a drag can leave the application
+publicbooleanisNativeDragOutsideApplicationSupported() {
+returnisNativeDragAndDropSupported();
+ }
+
+/// Hands the port the drag that would start if the press currently down turns into a drag.
+///
+/// Ports whose platform owns the gesture -- where the operating system's own recognizer
+/// decides a drag has begun and then asks what is being dragged -- answer from what they
+/// were given here. Ports that start the session themselves can ignore this and use
+/// `#startNativeDrag(com.codename1.ui.NativeDragOperation)`.
+///
+/// Invoked on the event dispatch thread, once per press. A press that produces no drag is
+/// followed by `#cancelNativeDrag()`.
+///
+/// #### Parameters
+///
+/// - `op`: the drag that is now possible
+publicvoidprepareNativeDrag(NativeDragOperationop) {
+ }
+
+/// Starts a native drag session now, because the pointer has moved far enough to be a drag.
+/// Invoked on the event dispatch thread while the pointer is still down.
+///
+/// A port that starts the session must eventually report the outcome through
+/// `com.codename1.ui.NativeDragAndDrop#dragCompleted(int)`, or a source that offered a move
+/// never learns whether to delete its copy.
+///
+/// #### Parameters
+///
+/// - `op`: what is being dragged
+///
+/// #### Returns
+///
+/// true when the operating system took the drag
+publicbooleanstartNativeDrag(NativeDragOperationop) {
+returnfalse;
+ }
+
+/// Discards whatever `#prepareNativeDrag(com.codename1.ui.NativeDragOperation)` staged,
+/// because the press turned out to be a click.
+publicvoidcancelNativeDrag() {
+ }
+
+/// Notifies the port that the application has a component that can be dragged through the
+/// operating system.
+///
+/// A platform whose drag gesture is its own -- UIKit's is -- recognizes that gesture with a
+/// recognizer installed on the surface, and installing one changes how every touch on that
+/// surface is delivered. Doing it unconditionally would alter touch handling for every
+/// application, including the overwhelming majority that never drags anything; a port that
+/// needs a recognizer therefore installs it here, the first time an application says it
+/// wants one.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDragSourceRegistered() {
+ }
+
+/// Notifies the port that the application has a component that accepts drops from the
+/// operating system.
+///
+/// The counterpart of `#nativeDragSourceRegistered()`, for the same reason: a port attaches
+/// whatever the platform needs in order to receive drops only for applications that asked
+/// to receive them, so an application that never does keeps exactly the input handling it
+/// had.
+///
+/// Called on the event dispatch thread, possibly many times; a port must make it idempotent.
+publicvoidnativeDropTargetRegistered() {
+ }
+
+/// True when the port needs the drag image at the moment the operation is staged rather
+/// than when the drag begins.
+///
+/// A port that starts the session itself renders the image then, which costs nothing for a
+/// press that turns out to be a click. A port whose platform owns the drag gesture is asked
+/// for the preview from inside that platform's own callback, which is not a moment at which
+/// a component can be rendered, so it has to have the image already.
+///
+/// #### Returns
+///
+/// true to render the drag image on every press over a native drag source
+publicbooleanisNativeDragImageNeededOnPrepare() {
+returnfalse;
+ }
+
 /// Performs a clipboard copy operation, if the native clipboard is supported by the implementation it would be used
 ///
 /// #### Parameters

CodenameOne/src/com/codename1/ui/ClipboardContent.java

@@ -46,12 +46,40 @@ public class ClipboardContent {
 publicstaticfinalStringMIME_GIF = "image/gif";
 /// A local file reference (a file path / URI `String`, or a `String[]` for several files).
 publicstaticfinalStringMIME_FILE = "application/x-file-list";
+/// A newline separated list of URIs, the format desktop browsers and file managers use when
+/// a link or a file is dragged out of them.
+publicstaticfinalStringMIME_URI_LIST = "text/uri-list";
 
 privatefinalList<String> mimeTypes = newArrayList<String>();
 privatefinalList<Object> values = newArrayList<Object>();
 
 /// Adds or replaces a representation. Passing null removes the MIME type.
 publicClipboardContentsetData(StringmimeType, Objectvalue) {
+returnput(mimeType, value);
+ }
+
+/// Declares a representation that is only built if something reads it, which is how a drag
+/// offers a file it has not written yet or an image it has not encoded yet.
+///
+/// The provider is asked at most once and its answer is then cached, so
+/// `#getData(java.lang.String)` behaves exactly as it would for a value passed to
+/// `#setData(java.lang.String, java.lang.Object)`. It may run on a native clipboard or drag
+/// thread; see `ClipboardDataProvider`. Passing a null provider removes the MIME type.
+///
+/// #### Parameters
+///
+/// - `mimeType`: the MIME type this provider can produce
+///
+/// - `provider`: the provider, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetDataProvider(StringmimeType, ClipboardDataProviderprovider) {
+returnput(mimeType, provider == null ? null : newLazyValue(provider));
+ }
+
+privateClipboardContentput(StringmimeType, Objectvalue) {
 Stringnormalized = normalizeMimeType(mimeType);
 if (normalized.length() == 0) {
 thrownewIllegalArgumentException("MIME type must not be empty");
@@ -74,9 +102,41 @@ public ClipboardContent setData(String mimeType, Object value) {
  }
 
 /// Returns the representation for a MIME type, or null when it isn't available.
+///
+/// A representation registered through
+/// `#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)` is produced
+/// here, on the first call for that MIME type.
 publicObjectgetData(StringmimeType) {
 intindex = mimeTypes.indexOf(normalizeMimeType(mimeType));
-returnindex < 0 ? null : values.get(index);
+if (index < 0) {
+returnnull;
+ }
+Objectvalue = values.get(index);
+if (valueinstanceofLazyValue) {
+return ((LazyValue) value).resolve(mimeTypes.get(index));
+ }
+returnvalue;
+ }
+
+/// A provider plus the value it produced. The value is resolved once and remembered, so a
+/// target that asks twice -- as a drop does when it queries and then reads -- does not run
+/// the provider twice and does not, for instance, write the promised file twice.
+privatestaticfinalclassLazyValue {
+privatefinalClipboardDataProviderprovider;
+privateObjectresolved;
+privatebooleandone;
+
+LazyValue(ClipboardDataProviderprovider) {
+this.provider = provider;
+ }
+
+synchronizedObjectresolve(StringmimeType) {
+if (!done) {
+done = true;
+resolved = provider.getClipboardData(mimeType);
+ }
+returnresolved;
+ }
  }
 
 /// Returns the binary (`byte[]`) representation for a MIME type -- e.g. the raw bytes of an image
@@ -102,6 +162,43 @@ public String[] getMimeTypes() {
 returnmimeTypes.toArray(newString[mimeTypes.size()]);
  }
 
+/// Sets the `#MIME_FILE` representation from a list of file paths or `file:` URIs.
+///
+/// Ports differ on whether a single file is carried as a `String` or a one element
+/// `String[]`; this writes the form the rest of the framework expects, and
+/// `#getFiles()` reads either.
+///
+/// #### Parameters
+///
+/// - `paths`: the file paths, or null to remove the representation
+///
+/// #### Returns
+///
+/// this instance, for chaining
+publicClipboardContentsetFiles(String[] paths) {
+if (paths == null || paths.length == 0) {
+returnsetData(MIME_FILE, null);
+ }
+if (paths.length == 1) {
+returnsetData(MIME_FILE, paths[0]);
+ }
+returnsetData(MIME_FILE, paths.clone());
+ }
+
+/// Returns the `#MIME_FILE` representation as a path array regardless of whether the
+/// producer stored one `String` or a `String[]`, or null when no files are available.
+publicString[] getFiles() {
+Objectvalue = getData(MIME_FILE);
+if (valueinstanceofString[]) {
+String[] paths = (String[]) value;
+returnpaths.length == 0 ? null : paths.clone();
+ }
+if (valueinstanceofString && ((String) value).length() > 0) {
+returnnewString[] { (String) value };
+ }
+returnnull;
+ }
+
 /// Returns the first available MIME type from the caller's preference list, or null.
 publicStringfindPreferredMimeType(String[] preferredMimeTypes) {
 if (preferredMimeTypes == null) {

CodenameOne/src/com/codename1/ui/ClipboardDataProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+
+package com.codename1.ui;
+
+/// Produces a clipboard or drag-and-drop representation on demand, so a payload that is
+/// expensive to build is only built if something actually asks for it.
+///
+/// This is what makes "drag a file out of the application" workable. A drag that offers
+/// `ClipboardContent#MIME_FILE` has to name the file when the drag *starts*, but the drop may
+/// never happen -- the user may let go over nothing -- and the target may prefer a different
+/// representation entirely. Registering a provider with
+/// `ClipboardContent#setDataProvider(java.lang.String, com.codename1.ui.ClipboardDataProvider)`
+/// declares that the representation is available without paying for it up front; the bytes are
+/// written, or the temporary file created, at the moment the receiving application reads that
+/// MIME type.
+///
+/// A provider is invoked at most once per `ClipboardContent` and MIME type -- the result is
+/// cached -- and it may be invoked from a native drag or clipboard thread rather than the event
+/// dispatch thread, so it must not touch the user interface.
+///
+/// #### When it actually runs
+///
+/// On the desktop and on iOS the provider runs when a receiver reads that representation, so a
+/// drag the user abandons costs nothing. Android is the exception: `startDragAndDrop` takes a
+/// complete clip, and a clip carries text or a reference to a file that already exists, so
+/// every provider runs as the drag begins. A drag out of an iOS application resolves its *file
+/// list* at the same moment for a related reason -- the system needs the number of items the
+/// drag carries, and for a file drag that is the number of files.
+///
+/// So a provider should be cheap enough to run once per drag, and must not assume it will only
+/// run when its data is wanted.
+public interface ClipboardDataProvider {
+ /// Produces the value for one representation.
+ ///
+ /// #### Parameters
+ ///
+ /// - `mimeType`: the MIME type being requested, always one this provider was registered for
+ ///
+ /// #### Returns
+ ///
+ /// the value, normally a `String`, a `String[]` of file paths or a `byte[]`, or null when
+ /// the representation turned out to be unavailable
+ Object getClipboardData(String mimeType);
+}