Doric/doric-iOS/Pod/Classes/Plugin/DoricShaderPlugin.m

/*
 * Copyright [2019] [Doric.Pub]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
//
//  DoricShaderPlugin.m
//  Doric
//
//  Created by pengfei.zhou on 2019/7/29.
//

#import "DoricShaderPlugin.h"
#import "DoricRootNode.h"
#import "DoricUtil.h"
#import "DoricExtensions.h"

#import <objc/runtime.h>

@implementation DoricShaderPlugin

- (DoricThreadMode)threadMode:(NSString *)method {
    return DoricThreadModeUI;
}

- (void)render:(NSDictionary *)argument withPromise:(DoricPromise *)promise {
    if (!argument) {
        return;
    }
    [self.doricContext.performanceProfile prepare:@"Render"];
    if (self.doricContext == nil) {
        return;
    }
    [self.doricContext.performanceProfile start:@"Render"];
    NSString *viewId = [argument optString:@"id"];

    if (self.doricContext.rootNode.viewId == nil && [@"Root" isEqualToString:[argument optString:@"type"]]) {
        self.doricContext.rootNode.viewId = viewId;
        [self.doricContext.rootNode blend:[argument optObject:@"props"]];
        [self.doricContext.rootNode requestLayout];
    } else {
        DoricViewNode *viewNode = [self.doricContext targetViewNode:viewId];
        [viewNode blend:[argument optObject:@"props"]];
        if (![viewNode isKindOfClass:DoricRootNode.class]) {
            [viewNode.view.doricLayout apply];
        }
        [viewNode requestLayout];
    }
    [promise resolve:nil];
    [self.doricContext.performanceProfile end:@"Render"];
}

- (void)command:(NSDictionary *)argument withPromise:(DoricPromise *)promise {
    if (self.doricContext == nil) {
        return;
    }
    NSArray *viewIds = [argument optArray:@"viewIds"];
    id args = argument[@"args"];
    NSString *name = [argument optString:@"name"];
    DoricViewNode *viewNode = nil;
    for (NSString *viewId in viewIds) {
        if (!viewNode) {
            viewNode = [self.doricContext targetViewNode:viewId];
        } else {
            if ([viewNode isKindOfClass:[DoricSuperNode class]]) {
                viewNode = [((DoricSuperNode *) viewNode) subNodeWithViewId:viewId];
            }
        }
    }
    if (!viewNode) {
        [promise reject:@"Cannot find opposite view"];
    } else {
        [self findClass:[viewNode class] target:viewNode method:name promise:promise argument:args];
    }
}

- (id)createParamWithMethodName:(NSString *)method promise:(DoricPromise *)promise argument:(id)argument {
    if ([method isEqualToString:@"withPromise"] || [method isEqualToString:@"promise"]) {
        return promise;
    }
    return argument;
}

- (void)findClass:(Class)clz target:(id)target method:(NSString *)name promise:(DoricPromise *)promise argument:(id)argument {
    unsigned int count;
    Method *methods = class_copyMethodList(clz, &count);
    BOOL isFound = NO;
    for (int i = 0; i < count; i++) {
        NSString *methodName = [NSString stringWithCString:sel_getName(method_getName(methods[i])) encoding:NSUTF8StringEncoding];
        NSArray *array = [methodName componentsSeparatedByString:@":"];
        if (array && [array count] > 0) {
            NSString *firstPart = array[0];
            if (![firstPart isEqualToString:name]) {
                firstPart = [firstPart componentsSeparatedByString:@"With"][0];
            }
            if ([firstPart isEqualToString:name]) {
                isFound = YES;
                SEL selector = NSSelectorFromString(methodName);
                NSMethodSignature *methodSignature = [target methodSignatureForSelector:selector];
                if (methodSignature) {
                    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSignature];
                    [invocation retainArguments];
                    invocation.selector = selector;
                    invocation.target = target;
                    void *retValue;
                    @try {
                        NSMutableArray *tempArray = [NSMutableArray new];

                        for (NSUInteger idx = 2; idx < methodSignature.numberOfArguments; idx++) {
                            if (idx - 2 > [array count]) {
                                break;
                            }
                            id param = [self createParamWithMethodName:array[idx - 2] promise:promise argument:argument];
                            if (param) {
                                [tempArray addObject:param];
                            }
                            [invocation setArgument:&param atIndex:idx];
                        }
                        [invocation invoke];
                    } @catch (NSException *exception) {
                        DoricLog(@"CallNative Error:%@", exception.reason);
                        [self.doricContext.driver.registry onException:exception inContext:self.doricContext];
                    }
                    const char *retType = methodSignature.methodReturnType;
                    if (!strcmp(retType, @encode(void))) {
                    } else {
                        [invocation getReturnValue:&retValue];
                        id returnValue = (__bridge id) retValue;
                        [promise resolve:returnValue];
                    }
                }
                break;
            }
        }
    }

    if (methods) {
        free(methods);
    }
    if (!isFound) {
        Class superclass = class_getSuperclass(clz);
        if (superclass && superclass != [NSObject class]) {
            [self findClass:superclass target:target method:name promise:promise argument:argument];
        }
    }
}

@end