Create a Titanium iOS module with ChatGPT

Creating a module for Titanium (Appcelerator) to share an image via text, email, Instagram, Facebook, or save to the local gallery requires several steps. Below is a detailed guide and sample code for creating an iOS module compatible with the latest version of Xcode and Swift.

1. Set Up Your Development Environment:

   • Ensure you have the latest version of Xcode installed.
   • Install Titanium SDK and Appcelerator CLI.
   • Create a new Titanium module project.

2. Create a New Module:

   • Use the Titanium CLI to create a new module:

     titanium create --type=module --name=ShareImage --platforms=iphone --id=com.example.shareimage
     

3. Open the Project in Xcode:

   • Navigate to the module’s ios directory and open the .xcodeproj file.

4. Add Sharing Functionality Using Swift:

   • Create a new Swift file in the Xcode project.
   • Implement the sharing functionality using UIActivityViewController to handle different sharing options.

swift
import UIKit

@objc(ShareImageModule)
class ShareImageModule: NSObject {

    @objc(share:image:callback:)
    func share(text: String, image: UIImage, callback: @escaping TiModuleCallback) {
        DispatchQueue.main.async {
            if let topController = UIApplication.shared.keyWindow?.rootViewController {
                let activityViewController = UIActivityViewController(activityItems: [text, image], applicationActivities: nil)
                activityViewController.excludedActivityTypes = [.assignToContact, .addToReadingList, .saveToCameraRoll]
                activityViewController.completionWithItemsHandler = { (activityType, completed, returnedItems, error) in
                    if completed {
                        callback([["success": true]])
                    } else {
                        callback([["success": false]])
                    }
                }
                topController.present(activityViewController, animated: true, completion: nil)
            } else {
                callback([["success": false]])
            }
        }
    }
}

5. Expose the Swift Code to Objective-C:

   • Ensure the Swift code is accessible from Objective-C by adding the necessary bridging headers if needed.
   • Update the module.xcconfig and module.xcodeproj files to include Swift support.

6. Update Module Configuration:

   • In timodule.xml, define the methods and properties exposed by your module.

   xml
   <module>
       <api-version>3</api-version>
       <version>1.0.0</version>
       <description>Share Image Module</description>
       <platform>iphone</platform>
       <minsdk>9.0.0</minsdk>
       <apis>
           <api name="Ti.Module">
               <method name="share" type="void">
                   <parameter name="text" type="String"/>
                   <parameter name="image" type="Ti.Blob"/>
                   <parameter name="callback" type="Function"/>
               </method>
           </api>
       </apis>
   </module>
   

7. Compile the Module:

   • Build the module using Titanium CLI:

     appc run -p ios --build-only
     

8. Distribute the Module:

   • Once the module is built, package it for distribution.
   • The compiled module can be found in the dist directory.

9. Integrate the Module in Your Titanium App:

   • Copy the module to the modules directory of your Titanium app.
   • Reference the module in your tiapp.xml file:

   xml
   <modules>
       <module platform="iphone">com.example.shareimage</module>
   </modules>
   

10. Use the Module in Your Titanium App:

• Below is an example of how to use the module in your Titanium app.

var shareImage = require('com.example.shareimage');
var imageBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg').read();
shareImage.share('Check out this image!', imageBlob, function(e) {
    if (e.success) {
        Ti.UI.createAlertDialog({message: 'Shared successfully!'}).show();
    } else {
        Ti.UI.createAlertDialog({message: 'Failed to share.'}).show();
    }
});

This guide walks you through the process of creating an iOS module for the Titanium ecosystem to share images via text, email, Instagram, Facebook, or save to the local gallery. It includes setting up your development environment, writing the Swift code, compiling the module, and integrating it into your Titanium app.

You should name the new Swift file something descriptive, such as ShareImageModule.swift. This file should be placed within the Classes directory of your Titanium module project. Here is a more detailed breakdown:

1. Navigate to the Classes directory of your Titanium module project. If it does not exist, create it.
2. Create a new Swift file named ShareImageModule.swift in the Classes directory.

vbnet
ShareImage
├── assets
├── example
├── ios
│   ├── Classes
│   │   ├── ShareImageModule.swift
│   ├── Resources
│   ├── ShareImage.xcodeproj
│   ├── ShareImage_Prefix.pch
│   ├── classes
│   ├── module.xcconfig
├── lib
├── timodule.xml
└── LICENSE

swift
import UIKit

@objc(ShareImageModule)
class ShareImageModule: NSObject {

    @objc(share:image:callback:)
    func share(text: String, image: TiBlob, callback: @escaping TiModuleCallback) {
        DispatchQueue.main.async {
            if let topController = UIApplication.shared.keyWindow?.rootViewController {
                let activityViewController = UIActivityViewController(activityItems: [text, image.image()], applicationActivities: nil)
                activityViewController.excludedActivityTypes = [.assignToContact, .addToReadingList]
                activityViewController.completionWithItemsHandler = { (activityType, completed, returnedItems, error) in
                    if completed {
                        callback([["success": true]])
                    } else {
                        callback([["success": false]])
                    }
                }
                topController.present(activityViewController, animated: true, completion: nil)
            } else {
                callback([["success": false]])
            }
        }
    }
}

If the project does not already include a bridging header file, you need to create one. You can name it ShareImage-Bridging-Header.h and place it in the ios directory.

objc
#import "TiModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"

Ensure the module.xcconfig file includes the path to the bridging header. Add the following line to module.xcconfig:

css
SWIFT_OBJC_BRIDGING_HEADER = ios/ShareImage-Bridging-Header.h

• Compile the module as mentioned previously:

  appc run -p ios --build-only
  

• Integrate and test the module in your Titanium app.

By following these steps, you will have a working Titanium module that includes Swift code to share images via various platforms.

Certainly! Here is the complete Swift file for ShareImageModule.swift:

swift
import UIKit

@objc(ShareImageModule)
class ShareImageModule: NSObject {

    @objc(share:image:callback:)
    func share(text: String, image: TiBlob, callback: @escaping TiModuleCallback) {
        DispatchQueue.main.async {
            if let topController = UIApplication.shared.keyWindow?.rootViewController {
                let activityViewController = UIActivityViewController(activityItems: [text, image.image()], applicationActivities: nil)
                activityViewController.excludedActivityTypes = [.assignToContact, .addToReadingList]
                activityViewController.completionWithItemsHandler = { (activityType, completed, returnedItems, error) in
                    if completed {
                        callback([["success": true]])
                    } else {
                        callback([["success": false]])
                    }
                }
                topController.present(activityViewController, animated: true, completion: nil)
            } else {
                callback([["success": false]])
            }
        }
    }
}

1. Create the Swift File:

   • Navigate to the Classes directory of your Titanium module project.
   • Create a new Swift file named ShareImageModule.swift.

2. Paste the Above Code:

   • Copy and paste the complete code provided above into ShareImageModule.swift.

3. Create Bridging Header:

   • If your project does not have a bridging header, create one named ShareImage-Bridging-Header.h in the ios directory.
   • Add the following to the bridging header:

     objc
     #import "TiModule.h"
     #import "TiBase.h"
     #import "TiHost.h"
     #import "TiUtils.h"
     

4. Update module.xcconfig:

   • Ensure the module.xcconfig includes the path to the bridging header by adding:

     css
     SWIFT_OBJC_BRIDGING_HEADER = ios/ShareImage-Bridging-Header.h
     

5. Build the Module:

   • Use the Titanium CLI to build the module:

     appc run -p ios --build-only
     

6. Integrate and Test:

   • Integrate the module into your Titanium app and test it using the example provided in the previous steps.

If there is no Classes directory in your Titanium module project, you can create it manually. Here is a more detailed step-by-step guide to create the Classes directory and place the Swift file within it:

1. Create the Classes Directory:

   • Navigate to the ios directory within your Titanium module project.
   • Create a new directory named Classes.

2. Create the Swift File:

   • Inside the Classes directory, create a new Swift file named ShareImageModule.swift.

3. Add the Complete Swift Code:

   • Open ShareImageModule.swift and paste the following code:

swift
import UIKit

@objc(ShareImageModule)
class ShareImageModule: NSObject {

    @objc(share:image:callback:)
    func share(text: String, image: TiBlob, callback: @escaping TiModuleCallback) {
        DispatchQueue.main.async {
            if let topController = UIApplication.shared.keyWindow?.rootViewController {
                let activityViewController = UIActivityViewController(activityItems: [text, image.image()], applicationActivities: nil)
                activityViewController.excludedActivityTypes = [.assignToContact, .addToReadingList]
                activityViewController.completionWithItemsHandler = { (activityType, completed, returnedItems, error) in
                    if completed {
                        callback([["success": true]])
                    } else {
                        callback([["success": false]])
                    }
                }
                topController.present(activityViewController, animated: true, completion: nil)
            } else {
                callback([["success": false]])
            }
        }
    }
}

4. Create a Bridging Header:
   • In the ios directory, create a file named ShareImage-Bridging-Header.h.
   • Add the following content to the ShareImage-Bridging-Header.h file:

objc
#import "TiModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"

5. Update module.xcconfig:
   • Open the module.xcconfig file located in the ios directory.
   • Add the following line to the module.xcconfig file to specify the bridging header:

css
SWIFT_OBJC_BRIDGING_HEADER = ios/ShareImage-Bridging-Header.h

6. Compile the Module:

   • Use the Titanium CLI to build the module:

     appc run -p ios --build-only
     

7. Integrate the Module in Your Titanium App:

   • Copy the built module to the modules directory of your Titanium app.
   • Reference the module in your tiapp.xml file:

   xml
   <modules>
       <module platform="iphone">com.example.shareimage</module>
   </modules>
   

8. Use the Module in Your Titanium App:

   • Below is an example of how to use the module in your Titanium app.

   var shareImage = require('com.example.shareimage');
   var imageBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg').read();
   shareImage.share('Check out this image!', imageBlob, function(e) {
       if (e.success) {
           Ti.UI.createAlertDialog({message: 'Shared successfully!'}).show();
       } else {
           Ti.UI.createAlertDialog({message: 'Failed to share.'}).show();
       }
   });
   

These steps guide you through creating a Titanium module with a Swift file for sharing images, setting up the necessary directories and files, compiling the module, and integrating it into your Titanium app.

If you prefer to use Objective-C instead of Swift, you can achieve the same functionality by creating an Objective-C class to handle the image sharing. Here is a detailed guide and the corresponding code for creating the ShareImageModule in Objective-C.

1. Create the Classes Directory:

   • Navigate to the ios directory within your Titanium module project.
   • Create a new directory named Classes if it doesn’t already exist.

2. Create the Objective-C Files:

   • Inside the Classes directory, create two files: ShareImageModule.h and ShareImageModule.m.

objc
#import "TiModule.h"
#import <UIKit/UIKit.h>

@interface ShareImageModule : TiModule

- (void)share:(id)args;

@end

objc
#import "ShareImageModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"

@implementation ShareImageModule

- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[[[TiApp app] controller] topPresentedController] topPresentedController];
        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

@end

3. Update the timodule.xml File:
   • Define the methods and properties exposed by your module.

xml
<module>
    <api-version>3</api-version>
    <version>1.0.0</version>
    <description>Share Image Module</description>
    <platform>iphone</platform>
    <minsdk>9.0.0</minsdk>
    <apis>
        <api name="Ti.Module">
            <method name="share" type="void">
                <parameter name="text" type="String"/>
                <parameter name="image" type="Ti.Blob"/>
                <parameter name="callback" type="Function"/>
            </method>
        </api>
    </apis>
</module>

4. Compile the Module:

   • Build the module using the Titanium CLI:

     appc run -p ios --build-only
     

5. Integrate the Module in Your Titanium App:

   • Copy the built module to the modules directory of your Titanium app.
   • Reference the module in your tiapp.xml file:

   xml
   <modules>
       <module platform="iphone">com.example.shareimage</module>
   </modules>
   

6. Use the Module in Your Titanium App:

   • Below is an example of how to use the module in your Titanium app.

var shareImage = require('com.example.shareimage');
var imageBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg').read();
shareImage.share({
    text: 'Check out this image!',
    image: imageBlob,
    callback: function(e) {
        if (e.success) {
            Ti.UI.createAlertDialog({message: 'Shared successfully!'}).show();
        } else {
            Ti.UI.createAlertDialog({message: 'Failed to share.'}).show();
        }
    }
});

These steps guide you through creating a Titanium module with Objective-C for sharing images. You create the necessary Objective-C files, compile the module, and integrate it into your Titanium app.

The error you’re encountering typically occurs when there is a syntax issue or an incorrect data type declaration in your Objective-C method. Let’s ensure that the method declaration and its implementation are correct and conform to the expected Titanium module patterns.

Here’s a revised approach:

objc
#import "TiModule.h"
#import <UIKit/UIKit.h>

@interface ShareImageModule : TiModule

- (void)share:(id)args;

@end

objc
#import "ShareImageModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"
#import "TiBlob.h"
#import "TiApp.h"

@implementation ShareImageModule

- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[[[TiApp app] controller] topPresentedController] topPresentedController];
        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

@end

1. Header File (ShareImageModule.h):

   • Ensure it includes necessary imports.
   • Declare the interface correctly.

2. Implementation File (ShareImageModule.m):

   • Ensure you import required headers.
   • Make sure that TiBlob, TiUtils, and KrollCallback are correctly imported.
   • ENSURE_SINGLE_ARG is a Titanium macro to ensure that the argument is a dictionary.
   • The method implementation retrieves parameters from the dictionary, handles image conversion, and uses UIActivityViewController for sharing.

1. Create the Classes Directory (if not existing):

   • Navigate to the ios directory within your Titanium module project.
   • Create a new directory named Classes.

2. Add Files:

   • Create ShareImageModule.h and ShareImageModule.m inside the Classes directory.
   • Copy the provided code into these files.

3. Compile the Module:

   • Use the Titanium CLI to build the module:

     appc run -p ios --build-only
     

4. Integrate and Test:

   • Copy the compiled module to your Titanium app’s modules directory.
   • Reference the module in your tiapp.xml.
   • Use the module in your Titanium app as previously described.

By following these steps, you should be able to resolve the syntax errors and properly implement the image sharing functionality in your Titanium module using Objective-C.

The ShareImageModule.m file should be an Objective-C implementation file (.m). It should be placed under the Classes directory of your Titanium module project. The class in this file should inherit from TiModule, which is the base class for all Titanium modules.

Here’s a detailed breakdown of where and how to create this file:

Your Titanium module’s ios directory should look like this:

vbnet
ShareImage
├── assets
├── example
├── ios
│   ├── Classes
│   │   ├── ShareImageModule.h
│   │   ├── ShareImageModule.m
│   ├── Resources
│   ├── ShareImage.xcodeproj
│   ├── ShareImage_Prefix.pch
│   ├── module.xcconfig
├── lib
├── timodule.xml
└── LICENSE

1. In the Classes directory, create a file named ShareImageModule.h.
2. Add the following code to ShareImageModule.h:

objc
#import "TiModule.h"
#import <UIKit/UIKit.h>

@interface ShareImageModule : TiModule

- (void)share:(id)args;

@end

1. In the Classes directory, create a file named ShareImageModule.m.
2. Add the following code to ShareImageModule.m:

objc
#import "ShareImageModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"
#import "TiBlob.h"
#import "TiApp.h"

@implementation ShareImageModule

- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[[[TiApp app] controller] topPresentedController] topPresentedController];
        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

@end

Ensure your timodule.xml is correctly configured to expose the share method. It should look like this:

xml
<module>
    <api-version>3</api-version>
    <version>1.0.0</version>
    <description>Share Image Module</description>
    <platform>iphone</platform>
    <minsdk>9.0.0</minsdk>
    <apis>
        <api name="Ti.Module">
            <method name="share" type="void">
                <parameter name="text" type="String"/>
                <parameter name="image" type="Ti.Blob"/>
                <parameter name="callback" type="Function"/>
            </method>
        </api>
    </apis>
</module>

Use the Titanium CLI to build the module:

appc run -p ios --build-only

1. Copy the built module to your Titanium app’s modules directory.
2. Reference the module in your tiapp.xml file:

xml
<modules>
    <module platform="iphone">com.example.shareimage</module>
</modules>

3. Use the module in your Titanium app as described in the previous steps:

var shareImage = require('com.example.shareimage');
var imageBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg').read();
shareImage.share({
    text: 'Check out this image!',
    image: imageBlob,
    callback: function(e) {
        if (e.success) {
            Ti.UI.createAlertDialog({message: 'Shared successfully!'}).show();
        } else {
            Ti.UI.createAlertDialog({message: 'Failed to share.'}).show();
        }
    }
});

By following these steps, you should have a working Objective-C implementation for sharing images in your Titanium module.

The error you’re encountering indicates that the definition of TiBlob is not available to your code. To resolve this, ensure you have the correct import statements for the Titanium Kit framework. Below are the adjusted steps and code snippets to fix the issue:

1. Import Titanium Kit: Ensure you import the Titanium Kit headers properly to use TiBlob.

objc
#import "TiModule.h"
#import <UIKit/UIKit.h>

@interface ShareImageModule : TiModule

- (void)share:(id)args;

@end

objc
#import "ShareImageModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"
#import "TiBlob.h"
#import "TiApp.h"

@implementation ShareImageModule

- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[[[TiApp app] controller] topPresentedController] topPresentedController];
        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

@end

Ensure the directory structure and file placements are correct.

vbnet
ShareImage
├── assets
├── example
├── ios
│   ├── Classes
│   │   ├── ShareImageModule.h
│   │   ├── ShareImageModule.m
│   ├── Resources
│   ├── ShareImage.xcodeproj
│   ├── ShareImage_Prefix.pch
│   ├── module.xcconfig
├── lib
├── timodule.xml
└── LICENSE

1. Build the Module:

   appc run -p ios --build-only
   

2. Integrate the Module:

   • Copy the compiled module to your Titanium app’s modules directory.
   • Reference the module in your tiapp.xml file:

     xml
     <modules>
         <module platform="iphone">com.example.shareimage</module>
     </modules>
     

3. Use the Module:

   var shareImage = require('com.example.shareimage');
   var imageBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg').read();
   shareImage.share({
       text: 'Check out this image!',
       image: imageBlob,
       callback: function(e) {
           if (e.success) {
               Ti.UI.createAlertDialog({message: 'Shared successfully!'}).show();
           } else {
               Ti.UI.createAlertDialog({message: 'Failed to share.'}).show();
           }
       }
   });
   

By ensuring the proper imports and structure, the Objective-C implementation should work as expected for your Titanium module to share images.

The error you’re encountering is due to the incorrect method call for obtaining the top-most view controller. The method topPresentedController doesn’t exist. Instead, you should use the presentedViewController property to find the top-most view controller.

Replace the following line:

objc
UIViewController *rootViewController = [[[[TiApp app] controller] topPresentedController] topPresentedController];

With this code to properly get the top-most view controller:

objc
UIViewController *rootViewController = [[TiApp app] controller];
while (rootViewController.presentedViewController) {
    rootViewController = rootViewController.presentedViewController;
}

Here is the modified part of your code:

objc
- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[TiApp app] controller];
        while (rootViewController.presentedViewController) {
            rootViewController = rootViewController.presentedViewController;
        }

        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

This change ensures that the rootViewController is correctly identified as the top-most view controller before presenting the UIActivityViewController.

Given the format of your timodule.xml, you will need to update the module’s XML to define the methods and properties exposed by your Objective-C module. Below is how you can structure your timodule.xml to include the share method.

xml
<?xml version="1.0" encoding="UTF-8"?>
<ti:module xmlns:ti="http://ti.tidev.io" xmlns:android="http://schemas.android.com/apk/res/android">
	<api-version>3</api-version>
    <version>1.0.0</version>
    <description>Share Image Module</description>
    <platform>iphone</platform>
    <minsdk>9.0.0</minsdk>
	<iphone>
		<apis>
			<api name="Ti.Module">
				<method name="share" type="void">
					<parameter name="text" type="String"/>
					<parameter name="image" type="Ti.Blob"/>
					<parameter name="callback" type="Function"/>
				</method>
			</api>
		</apis>
	</iphone>
	<android xmlns:android="http://schemas.android.com/apk/res/android">
		<!-- Android specific configuration can go here -->
	</android>
</ti:module>

• The iphone section contains the API definitions for the iOS platform.
• The apis tag defines the APIs exposed by your module.
• The api tag specifies the class and the methods exposed by your module.
• The method tag defines the share method with its parameters.

The code remains largely the same, but make sure it matches the defined method in timodule.xml.

objc
#import "ShareImageModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"
#import "TiBlob.h"
#import "TiApp.h"

@implementation ShareImageModule

- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[TiApp app] controller];
        while (rootViewController.presentedViewController) {
            rootViewController = rootViewController.presentedViewController;
        }

        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

@end

• Update your timodule.xml to define the share method and its parameters.
• Ensure your Objective-C implementation matches the defined API in the timodule.xml.

By following these steps, you should have a properly configured Titanium module for sharing images on iOS.

To build a Titanium module for iOS, you should use the appc ti build command instead. Here are the corrected steps for building the module:

1. Navigate to the Module Directory: Open a terminal and navigate to the root directory of your module.

   cd path/to/your/module
   

2. Build the Module: Use the following command to build the iOS module. Make sure you specify the correct target and platform.

   appc ti build -p ios --build-only
   

1. Navigate to the Module Directory:

   cd path/to/your/module
   

2. Build the Module:

   appc ti build -p ios --build-only
   

3. Integrate the Module in Your Titanium App:

   • Copy the compiled module from the dist directory to your Titanium app’s modules directory.

4. Reference the Module in Your tiapp.xml:

   xml
   <modules>
       <module platform="iphone">com.example.shareimage</module>
   </modules>
   

5. Use the Module in Your Titanium App:

   var shareImage = require('com.example.shareimage');
   var imageBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg').read();
   shareImage.share({
       text: 'Check out this image!',
       image: imageBlob,
       callback: function(e) {
           if (e.success) {
               Ti.UI.createAlertDialog({message: 'Shared successfully!'}).show();
           } else {
               Ti.UI.createAlertDialog({message: 'Failed to share.'}).show();
           }
       }
   });
   

Ensure the Objective-C implementation matches the defined method in timodule.xml.

objc
#import "ShareImageModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"
#import "TiBlob.h"
#import "TiApp.h"

@implementation ShareImageModule

- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[TiApp app] controller];
        while (rootViewController.presentedViewController) {
            rootViewController = rootViewController.presentedViewController;
        }

        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

@end

xml
<?xml version="1.0" encoding="UTF-8"?>
<ti:module xmlns:ti="http://ti.tidev.io" xmlns:android="http://schemas.android.com/apk/res/android">
    <api-version>3</api-version>
    <version>1.0.0</version>
    <description>Share Image Module</description>
    <platform>iphone</platform>
    <minsdk>9.0.0</minsdk>
    <iphone>
        <apis>
            <api name="Ti.Module">
                <method name="share" type="void">
                    <parameter name="text" type="String"/>
                    <parameter name="image" type="Ti.Blob"/>
                    <parameter name="callback" type="Function"/>
                </method>
            </api>
        </apis>
    </iphone>
    <android xmlns:android="http://schemas.android.com/apk/res/android">
        <!-- Android specific configuration can go here -->
    </android>
</ti:module>

By following these steps, you should be able to successfully build and integrate your Titanium module for sharing images on iOS.

Certainly! To help troubleshoot your build failure, let’s follow a systematic approach:

1. Check the Build Log:

   • Carefully review the build log for any error messages or warnings. This will provide specific clues about what went wrong.

2. Common Issues and Fixes:

   • Missing Headers: Ensure all necessary headers are included in ShareImageModule.m:

     objc
     #import "ShareImageModule.h"
     #import "TiBase.h"
     #import "TiHost.h"
     #import "TiUtils.h"
     #import "TiBlob.h"
     #import "TiApp.h"
     

   • Correct Import Path: Double-check the paths to the headers to make sure they are correct and the files exist.

   • Objective-C Syntax: Verify that there are no syntax errors in your Objective-C code.

3. Run appc ti build with Verbose Logging:

   • Run the build command with verbose logging to get more detailed output:

     appc ti build -p ios --build-only --log-level trace
     

4. Ensure Xcode and Titanium SDK are Up-to-Date:

   • Make sure you are using the latest versions of Xcode and the Titanium SDK.

5. Clean the Build:

   • Sometimes, cleaning the build can resolve issues:

     appc ti clean
     

6. Sample Code and Configuration:

   • Here’s the complete setup for your module again, in case there are any discrepancies.

objc
#import "TiModule.h"
#import <UIKit/UIKit.h>

@interface ShareImageModule : TiModule

- (void)share:(id)args;

@end

objc
#import "ShareImageModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"
#import "TiBlob.h"
#import "TiApp.h"

@implementation ShareImageModule

- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[TiApp app] controller];
        while (rootViewController.presentedViewController) {
            rootViewController = rootViewController.presentedViewController;
        }

        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

@end

xml
<?xml version="1.0" encoding="UTF-8"?>
<ti:module xmlns:ti="http://ti.tidev.io" xmlns:android="http://schemas.android.com/apk/res/android">
    <api-version>3</api-version>
    <version>1.0.0</version>
    <description>Share Image Module</description>
    <platform>iphone</platform>
    <minsdk>9.0.0</minsdk>
    <iphone>
        <apis>
            <api name="Ti.Module">
                <method name="share" type="void">
                    <parameter name="text" type="String"/>
                    <parameter name="image" type="Ti.Blob"/>
                    <parameter name="callback" type="Function"/>
                </method>
            </api>
        </apis>
    </iphone>
    <android xmlns:android="http://schemas.android.com/apk/res/android">
        <!-- Android specific configuration can go here -->
    </android>
</ti:module>

1. Ensure you are in the correct directory: Make sure you are running the build command in the root directory of your module.

2. Xcode Project Settings:

   • Open the generated Xcode project file in ios/ShareImage.xcodeproj.
   • Ensure that the correct deployment target is set.
   • Check for any issues or warnings in Xcode.

If you still encounter issues, please provide the specific error messages from the build log so I can offer more precise assistance.

To convert an image into a TiBlob in Titanium, you can use the Ti.Filesystem and Ti.UI APIs. Below are the steps and an example code snippet to convert an image into a blob:

1. Load an Image from the Filesystem:

   • Use Ti.Filesystem to load an image file and convert it into a blob.

2. Convert an Image View into a Blob:

   • Use Ti.UI.ImageView to load an image and then use its toBlob() method to convert it into a blob.

var imageFile = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg');
var imageBlob = imageFile.read();

var imageView = Ti.UI.createImageView({
    image: 'example.jpg',
    width: 200,
    height: 200
});

// Convert the image view to a blob
var imageBlob = imageView.toBlob();

Here’s how you can integrate this into your Titanium app, including loading an image, converting it to a blob, and using the share method from your custom module.

var shareImage = require('com.example.shareimage');

// Load an image from the filesystem and convert it to a blob
var imageFile = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg');
var imageBlob = imageFile.read();

// Alternatively, you can use an ImageView to load and convert the image
// var imageView = Ti.UI.createImageView({ image: 'example.jpg', width: 200, height: 200 });
// var imageBlob = imageView.toBlob();

shareImage.share({
    text: 'Check out this image!',
    image: imageBlob,
    callback: function(e) {
        if (e.success) {
            Ti.UI.createAlertDialog({ message: 'Shared successfully!' }).show();
        } else {
            Ti.UI.createAlertDialog({ message: 'Failed to share.' }).show();
        }
    }
});

If you encounter build failures when working with your custom module, make sure:

1. All Required Headers are Included:

   • Ensure you have included all necessary headers in your Objective-C files.

2. Check for Correct Method Implementations:

   • Ensure your methods in the module match the definitions in timodule.xml.

3. Verbose Build Logs:

   • Use verbose logging to get detailed information about the build errors:

     appc ti build -p ios --build-only --log-level trace
     

4. Clean Build:

   • Perform a clean build to ensure there are no stale artifacts:

     appc ti clean
     appc ti build -p ios --build-only
     

If you encounter specific errors during the build, please provide the error messages so I can offer more targeted assistance.

If you are creating an image out of multiple UI components, you can use the toImage() method in Titanium to convert a view hierarchy into a blob. Here’s how you can do it:

1. Create a Container View:

   • Create a parent view that will hold all the UI components.

2. Add Components to the Container View:

   • Add your UI components (e.g., labels, images, buttons) to the container view.

3. Convert the Container View to an Image:

   • Use the toImage() method to capture the container view as an image blob.

Here is an example that demonstrates how to create an image from multiple UI components and then share it using your custom module:

var shareImage = require('com.example.shareimage');

// Step 1: Create a container view
var containerView = Ti.UI.createView({
    width: Ti.UI.SIZE,
    height: Ti.UI.SIZE,
    backgroundColor: 'white'
});

// Step 2: Add components to the container view
var label = Ti.UI.createLabel({
    text: 'Hello, World!',
    color: 'black',
    top: 10,
    left: 10
});
containerView.add(label);

var imageView = Ti.UI.createImageView({
    image: 'example.jpg',
    width: 200,
    height: 200,
    top: 40,
    left: 10
});
containerView.add(imageView);

var button = Ti.UI.createButton({
    title: 'Click Me!',
    top: 260,
    left: 10
});
containerView.add(button);

// Step 3: Convert the container view to an image blob
var imageBlob = containerView.toImage();

// Step 4: Use the custom share module to share the image
shareImage.share({
    text: 'Check out this composite image!',
    image: imageBlob,
    callback: function(e) {
        if (e.success) {
            Ti.UI.createAlertDialog({ message: 'Shared successfully!' }).show();
        } else {
            Ti.UI.createAlertDialog({ message: 'Failed to share.' }).show();
        }
    }
});

• Container View: A parent view (containerView) is created to hold all the UI components.
• Add Components: Various UI components (e.g., a label, an image view, and a button) are added to the container view.
• Convert to Image: The toImage() method is called on the container view to convert it to a blob.
• Share Image: The share method of the custom module is called to share the created image blob.

• Customizing Components: You can add more UI components or customize them as needed. The toImage() method will capture the entire view hierarchy.
• Handling Layout: Ensure that your layout is properly sized and positioned to fit within the container view.
• Asynchronous toImage(): If your view is complex or if you want to ensure that the view is fully rendered before capturing it, you can use the asynchronous version of toImage():

  containerView.toImage(function(blob) {
      // Share the image blob
      shareImage.share({
          text: 'Check out this composite image!',
          image: blob,
          callback: function(e) {
              if (e.success) {
                  Ti.UI.createAlertDialog({ message: 'Shared successfully!' }).show();
              } else {
                  Ti.UI.createAlertDialog({ message: 'Failed to share.' }).show();
              }
          }
      });
  });
  

This approach allows you to create a composite image from multiple UI components and then share it using your custom Titanium module.

The module we have created leverages the UIActivityViewController, which is part of the iOS SDK. This controller provides a standard interface for sharing content with various services, including social media apps that are installed on the user’s device.

Here’s how it works:

• UIActivityViewController: This controller automatically detects and lists the sharing options available on the device. These options can include email, text message, social media apps (like Facebook, Twitter, Instagram), and other apps that support the type of content you are sharing.

• Excluded Activity Types: You can exclude certain sharing options if needed. For example, if you do not want to include certain types of activities (like saving to a reading list), you can specify those in the excludedActivityTypes property.

In the provided code, we are already using UIActivityViewController:

objc
- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    UIImage *image = [imageBlob image];
    NSArray *activityItems = @[text, image];

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[TiApp app] controller];
        while (rootViewController.presentedViewController) {
            rootViewController = rootViewController.presentedViewController;
        }

        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

1. Include the Module in Your App: Ensure the module is correctly integrated into your Titanium app.

2. Prepare Content to Share: Use the module to share content, such as text and images, as demonstrated in the previous examples.

Here’s how you can use the module to share an image composed of multiple UI components:

var shareImage = require('com.example.shareimage');

// Create a container view with multiple UI components
var containerView = Ti.UI.createView({
    width: Ti.UI.SIZE,
    height: Ti.UI.SIZE,
    backgroundColor: 'white'
});

var label = Ti.UI.createLabel({
    text: 'Hello, World!',
    color: 'black',
    top: 10,
    left: 10
});
containerView.add(label);

var imageView = Ti.UI.createImageView({
    image: 'example.jpg',
    width: 200,
    height: 200,
    top: 40,
    left: 10
});
containerView.add(imageView);

var button = Ti.UI.createButton({
    title: 'Click Me!',
    top: 260,
    left: 10
});
containerView.add(button);

// Convert the container view to an image blob
var imageBlob = containerView.toImage();

// Share the image using the custom module
shareImage.share({
    text: 'Check out this composite image!',
    image: imageBlob,
    callback: function(e) {
        if (e.success) {
            Ti.UI.createAlertDialog({ message: 'Shared successfully!' }).show();
        } else {
            Ti.UI.createAlertDialog({ message: 'Failed to share.' }).show();
        }
    }
});

When the UIActivityViewController is presented, it will automatically display sharing options for any social media apps installed on the device that support sharing the type of content you are providing (text, images, etc.). Common supported apps include:

• Facebook
• Twitter
• Instagram
• WhatsApp
• Email Clients (Mail app)
• Messaging Apps (iMessage, SMS)

If you want to customize the list of available sharing options or exclude certain services, you can modify the excludedActivityTypes property:

objc
activityViewController.excludedActivityTypes = @[
    UIActivityTypeAssignToContact,
    UIActivityTypeAddToReadingList,
    // Add any other types you want to exclude
];

By using the UIActivityViewController, your module will automatically support a wide range of sharing options, including popular social media apps, without needing to write specific integrations for each one.

To update the module version in your Titanium module, you need to change the version number in the timodule.xml file. This file is located in the root directory of your module project.

1. Open timodule.xml:

   • Navigate to the root directory of your Titanium module project.
   • Open the timodule.xml file in a text editor.

2. Locate the <version> Tag:

   • Find the <version> tag inside the timodule.xml file.

3. Update the Version Number:

   • Change the version number to the new version you want to set.

Here is how your timodule.xml might look before and after updating the version number.

xml
<?xml version="1.0" encoding="UTF-8"?>
<ti:module xmlns:ti="http://ti.tidev.io" xmlns:android="http://schemas.android.com/apk/res/android">
    <api-version>3</api-version>
    <version>1.0.0</version>
    <description>Share Image Module</description>
    <platform>iphone</platform>
    <minsdk>9.0.0</minsdk>
    <iphone>
        <apis>
            <api name="Ti.Module">
                <method name="share" type="void">
                    <parameter name="text" type="String"/>
                    <parameter name="image" type="Ti.Blob"/>
                    <parameter name="callback" type="Function"/>
                </method>
            </api>
        </apis>
    </iphone>
    <android xmlns:android="http://schemas.android.com/apk/res/android">
        <!-- Android specific configuration can go here -->
    </android>
</ti:module>

xml
<?xml version="1.0" encoding="UTF-8"?>
<ti:module xmlns:ti="http://ti.tidev.io" xmlns:android="http://schemas.android.com/apk/res/android">
    <api-version>3</api-version>
    <version>1.1.0</version>
    <description>Share Image Module</description>
    <platform>iphone</platform>
    <minsdk>9.0.0</minsdk>
    <iphone>
        <apis>
            <api name="Ti.Module">
                <method name="share" type="void">
                    <parameter name="text" type="String"/>
                    <parameter name="image" type="Ti.Blob"/>
                    <parameter name="callback" type="Function"/>
                </method>
            </api>
        </apis>
    </iphone>
    <android xmlns:android="http://schemas.android.com/apk/res/android">
        <!-- Android specific configuration can go here -->
    </android>
</ti:module>

• Open the timodule.xml file in the root directory of your Titanium module project.
• Locate the <version> tag.
• Update the version number to the new version you want to set.

This change will update the version number of your module, which is important for version tracking and ensuring that your app uses the correct module version.

To make the module more universal and capable of sharing either an image or text (or both), you can adjust the share method to accept either type of content and handle the logic accordingly. Here’s how you can modify the code to support sharing text, an image, or both:

Modify the share method in ShareImageModule.m to handle both text and image content dynamically.

No changes needed here; keep the interface declaration as is.

objc
#import "TiModule.h"
#import <UIKit/UIKit.h>

@interface ShareImageModule : TiModule

- (void)share:(id)args;

@end

Update the share method to conditionally add text and image to the activity items.

objc
#import "ShareImageModule.h"
#import "TiBase.h"
#import "TiHost.h"
#import "TiUtils.h"
#import "TiBlob.h"
#import "TiApp.h"

@implementation ShareImageModule

- (void)share:(id)args {
    ENSURE_SINGLE_ARG(args, NSDictionary);

    NSString *text = [TiUtils stringValue:@"text" properties:args def:nil];
    TiBlob *imageBlob = [args objectForKey:@"image"];
    KrollCallback *callback = [args objectForKey:@"callback"];

    NSMutableArray *activityItems = [NSMutableArray array];
    if (text != nil) {
        [activityItems addObject:text];
    }
    if (imageBlob != nil) {
        UIImage *image = [imageBlob image];
        [activityItems addObject:image];
    }

    if ([activityItems count] == 0) {
        if (callback != nil) {
            NSDictionary *event = @{@"success": @(NO), @"message": @"No content to share"};
            [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
        }
        return;
    }

    dispatch_async(dispatch_get_main_queue(), ^{
        UIViewController *rootViewController = [[TiApp app] controller];
        while (rootViewController.presentedViewController) {
            rootViewController = rootViewController.presentedViewController;
        }

        UIActivityViewController *activityViewController = [[UIActivityViewController alloc] initWithActivityItems:activityItems applicationActivities:nil];

        activityViewController.excludedActivityTypes = @[UIActivityTypeAssignToContact, UIActivityTypeAddToReadingList];

        activityViewController.completionWithItemsHandler = ^(UIActivityType activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
            if (callback != nil) {
                NSDictionary *event = @{@"success": @(completed)};
                [self _fireEventToListener:@"callback" withObject:event listener:callback thisObject:nil];
            }
        };

        [rootViewController presentViewController:activityViewController animated:YES completion:nil];
    });
}

@end

Ensure your timodule.xml file reflects the updated method signature, allowing both text and image parameters to be optional.

xml
<?xml version="1.0" encoding="UTF-8"?>
<ti:module xmlns:ti="http://ti.tidev.io" xmlns:android="http://schemas.android.com/apk/res/android">
    <api-version>3</api-version>
    <version>1.1.0</version>
    <description>Universal Share Module</description>
    <platform>iphone</platform>
    <minsdk>9.0.0</minsdk>
    <iphone>
        <apis>
            <api name="Ti.Module">
                <method name="share" type="void">
                    <parameter name="text" type="String" optional="true"/>
                    <parameter name="image" type="Ti.Blob" optional="true"/>
                    <parameter name="callback" type="Function" optional="true"/>
                </method>
            </api>
        </apis>
    </iphone>
    <android xmlns:android="http://schemas.android.com/apk/res/android">
        <!-- Android specific configuration can go here -->
    </android>
</ti:module>

You can now use the module to share text, an image, or both. Here are a few examples:

var shareImage = require('com.example.shareimage');

shareImage.share({
    text: 'Check out this text!',
    callback: function(e) {
        if (e.success) {
            Ti.UI.createAlertDialog({ message: 'Shared successfully!' }).show();
        } else {
            Ti.UI.createAlertDialog({ message: 'Failed to share.' }).show();
        }
    }
});

var shareImage = require('com.example.shareimage');
var imageBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg').read();

shareImage.share({
    image: imageBlob,
    callback: function(e) {
        if (e.success) {
            Ti.UI.createAlertDialog({ message: 'Shared successfully!' }).show();
        } else {
            Ti.UI.createAlertDialog({ message: 'Failed to share.' }).show();
        }
    }
});

var shareImage = require('com.example.shareimage');
var imageBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'example.jpg').read();

shareImage.share({
    text: 'Check out this image!',
    image: imageBlob,
    callback: function(e) {
        if (e.success) {
            Ti.UI.createAlertDialog({ message: 'Shared successfully!' }).show();
        } else {
            Ti.UI.createAlertDialog({ message: 'Failed to share.' }).show();
        }
    }
});

This approach makes your sharing module versatile, allowing it to handle various types of content dynamically.